int main() { //TreeNode_ptr T; //T = Create_Binarytree(); TreeNode_ptr TreeNode_ptr4 = CreateNode(4); TreeNode_ptr TreeNode_ptr2 = CreateNode(2); TreeNode_ptr TreeNode_ptr3 = CreateNode(3); TreeNode_ptr TreeNode_ptr1 = CreateNode(1); TreeNode_ptr TreeNode_ptr6 = CreateNode(6); TreeNode_ptr TreeNode_ptr5 = CreateNode(5); TreeNode_ptr TreeNode_ptr7 = CreateNode(7); ConnectNodes(TreeNode_ptr4, TreeNode_ptr2, TreeNode_ptr6); ConnectNodes(TreeNode_ptr2, TreeNode_ptr1, TreeNode_ptr3); ConnectNodes(TreeNode_ptr6, TreeNode_ptr5, TreeNode_ptr7); printf("\n中序遍历为:"); Inorder_Traversal(TreeNode_ptr4); printf("\n转化为双向链表:"); TreeNode_ptr Head = ConventToDList(TreeNode_ptr4); while(NULL != Head) { printf("%d ",Head->data); Head = Head->rightchild; } printf("\n"); }
void InputTreeBuilder::Build(const TreeInput &in, const std::string &topLevelLabel, InputTree &out) { CreateNodes(in, topLevelLabel, out); ConnectNodes(out); }
/* * Places traces in a particular linear order * to maximize sequential transition. * A good way to achieve this is to construct a * higher level graph, using traces as nodes. * An arc is added between traces whose head * and tail are connected by a transition. */ static void PlaceTraces (FGraph graph) { FGraph new_graph; Node node, current; Node node_order[MAX_GRAPH_SIZE]; int i, size; #ifndef SECOND_LEVEL_SELECT int min_trace_id, max_trace_id; #endif if (graph->nodes == 0) return; #ifdef SECOND_LEVEL_SELECT new_graph = NewGraph (); /* create a high level graph */ for (node = graph->nodes; node != 0; node = nextNode (node)) { int trace_id; Node temp; trace_id = nodeType (node); temp = FindNode (new_graph, trace_id); if (temp == 0) { temp = NewNode (); nodeId (temp) = trace_id; AddNode (new_graph, temp); } if (node == graph->root) new_graph->root = temp; } for (node = graph->nodes; node != 0; node = nextNode (node)) { Arc arc; if (!(nodeStatus (node) & TRACE_TAIL)) continue; /* * Find transitions to the head of other traces. * Inner loop back-edge is not considered. */ for (arc = destinationArcs (node); arc != 0; arc = nextArc (arc)) { Node dest; dest = destinationNode (arc); if ((nodeType (dest) != nodeType (node)) && (nodeStatus (dest) & TRACE_HEAD)) { /* * Add a link (trace[node]->trace[dest]) */ int src_trace_id, dest_trace_id; Node src_node, dest_node; Arc ar; src_trace_id = nodeType (node); dest_trace_id = nodeType (dest); src_node = FindNode (new_graph, src_trace_id); dest_node = FindNode (new_graph, dest_trace_id); ConnectNodes (src_node, dest_node, 0); ar = FindSrcArc (src_node, dest_node, 0); arcWeight (ar) = arcWeight (arc); ar = FindDestArc (src_node, dest_node, 0); arcWeight (ar) = arcWeight (arc); } } } /* * Simply assign the node weights to max(connecting arc) */ for (node = new_graph->nodes; node != 0; node = nextNode (node)) { Arc arc; double max = 1.0; for (arc = sourceArcs (node); arc != 0; arc = nextArc (arc)) if (arcWeight (arc) > max) max = arcWeight (arc); for (arc = destinationArcs (node); arc != 0; arc = nextArc (arc)) if (arcWeight (arc) > max) max = arcWeight (arc); nodeWeight (node) = max; } /* * Apply SelectTraces() on the new graph. * Use SELECT_BY_ARC_WEIGHT */ best_successor_of = best_successor_2; best_predecessor_of = best_predecessor_2; SelectTraces (new_graph); /* * Determine the best sequential order of the traces. * Essentially, we have the original problem again. * However, after the second level trace selection, * we expect most of the sequential transitions are * captured. A naive heuristic is sufficient here. * The sequential order must start with the ENTRY trace. */ #ifdef DEBUG_TRACE1 printf ("... second level graph = \n"); WriteGraph ("stdout", new_graph); #endif /* * Clear the valid bit of all nodes. */ for (node = new_graph->nodes; node != 0; node = nextNode (node)) { nodeStatus (node) &= ~VISITED; } /* * Start from the root node. */ size = 0; current = new_graph->root; while (current != 0) { Node ptr; Arc ar; int trace_id; if (nodeStatus (current) & VISITED) Punt ("PlaceTraces: reached a VISITed node"); nodeStatus (current) |= VISITED; trace_id = nodeId (current); /* * Layout the trace. */ for (ptr = graph->nodes; ptr != 0; ptr = nextNode (ptr)) { if ((nodeType (ptr) == trace_id) && (nodeStatus (ptr) & TRACE_HEAD)) break; /* find the starting node of the trace */ } if (ptr == 0) Punt ("PlaceTraces: internal error (1)"); while (ptr != 0) { Arc next; node_order[size++] = ptr; /* * Follow the in-trace transition. */ if (nodeStatus (ptr) & TRACE_TAIL) break; /* reached the end of trace */ for (next = destinationArcs (ptr); next != 0; next = nextArc (next)) { if (arcType (next) == nodeType (ptr)) break; /* find a in-trace transition */ } if (next == 0) break; ptr = destinationNode (next); } /* * Select the next trace to be visited next. * Follow an in-trace transition (of the higher level * graph) if possible. */ for (ar = destinationArcs (current); ar != 0; ar = nextArc (ar)) { if (arcType (ar) == nodeType (current)) break; /* find an in-trace transition */ } if (ar != 0) { /* transition is still in-trace */ current = destinationNode (ar); } else { /* must find another trace */ /* * Find the most important trace left. */ Node nn, best; best = 0; for (nn = new_graph->nodes; nn != 0; nn = nextNode (nn)) { if (nodeStatus (nn) & VISITED) continue; /* skip over VISITED nodes */ if (!(nodeStatus (nn) & TRACE_HEAD)) continue; /* skip over non-trace headers */ if (best == 0) { best = nn; } else { if (nodeWeight (nn) > nodeWeight (best)) best = nn; } } current = best; /* go out of trace if best=0 */ } } /* * Make sure that all traces have been layout. */ for (node = new_graph->nodes; node != 0; node = nextNode (node)) { if (!(nodeStatus (node) & VISITED)) { Punt ("PlaceTraces: missing some traces"); } } /* * No longer need the higher level graph. */ FreeGraph (&new_graph); /* destroy the high level graph */ #else min_trace_id = 0x1FFFFFFF; max_trace_id = -0x1FFFFFFF; for (node = graph->nodes; node != 0; node = nextNode (node)) { int trace_id; trace_id = nodeType (node); if (trace_id > max_trace_id) max_trace_id = trace_id; if (trace_id < min_trace_id) min_trace_id = trace_id; } for (node = graph->nodes; node != 0; node = nextNode (node)) { nodeStatus (node) &= ~VISITED; } size = 0; for (i = min_trace_id; i <= max_trace_id; i++) { Node ptr; /* * 1. find the trace header. */ for (ptr = graph->nodes; ptr != 0; ptr = nextNode (ptr)) { if ((nodeType (ptr) == i) & ((nodeStatus (ptr) & TRACE_HEAD) != 0)) break; } if (ptr == 0) continue; while (ptr != 0) { Arc next; if (nodeStatus (ptr) & VISITED) Punt ("PlaceTraces: visited a node twice"); nodeStatus (ptr) |= VISITED; node_order[size++] = ptr; if (nodeStatus (ptr) & TRACE_TAIL) break; for (next = destinationArcs (ptr); next != 0; next = nextArc (next)) { if (arcType (next) == nodeType (ptr)) break; } if (next == 0) break; ptr = destinationNode (next); } } /* * Make sure that all traces have been layout. */ for (node = graph->nodes; node != 0; node = nextNode (node)) { if (!(nodeStatus (node) & VISITED)) { fprintf (stderr, "min trace id = %d\n", min_trace_id); fprintf (stderr, "max trace id = %d\n", max_trace_id); fprintf (stderr, "size = %d\n", size); WriteGraph ("stderr", graph); Punt ("PlaceTraces: missing some traces"); } } #endif /* * Rearrange the order of nodes, according to the * node_order[] order. */ node_order[size] = 0; for (i = 0; i < size; i++) { nextNode (node_order[i]) = node_order[i + 1]; } graph->nodes = node_order[0]; }
status_t Controller::ConnectInterface(int i) { if (i < 0) { printf("Controller::ConnectInterface: wrong index\n"); return B_ERROR; } if (fCurrentInterface != -1) { printf("Controller::ConnectInterface: already connected\n"); return B_ERROR; } BParameterWeb *web; status_t err; err = gDeviceRoster->MediaRoster()->GetParameterWebFor(gDeviceRoster->DeviceNode(i), &web); if (err != B_OK) { printf("Controller::ConnectInterface: can't get parameter web\n"); return B_ERROR; } delete fWeb; fWeb = web; fCurrentInterface = i; // XXX we may need to monitor for parameter web changes // and reassing fWeb and fChannelParam on demand. // find the channel control and assign it to fChannelParam fChannelParam = NULL; int count = fWeb->CountParameters(); for (int i = 0; i < count; i++) { BParameter *parameter = fWeb->ParameterAt(i); printf("parameter %d\n", i); printf(" name '%s'\n", parameter->Name()); printf(" kind '%s'\n", parameter->Kind()); printf(" unit '%s'\n", parameter->Unit()); printf(" flags 0x%08" B_PRIx32 "\n", parameter->Flags()); // XXX TODO: matching on Name is weak if (strcmp(parameter->Name(), "Channel") == 0 || strcmp(parameter->Kind(), B_TUNER_CHANNEL) == 0) { fChannelParam = dynamic_cast<BDiscreteParameter *>(parameter); if (fChannelParam) break; } } if (!fChannelParam) { printf("Controller::ConnectInterface: can't find channel parameter control\n"); fCurrentChannel = -1; } else { if (fChannelParam->CountItems() == 0) { fCurrentChannel = -1; printf("Controller::ConnectInterface: channel control has 0 items\n"); } else { int32 index; size_t size; status_t err; bigtime_t when; size = sizeof(index); err = fChannelParam->GetValue(&index, &size, &when); if (err == B_OK && size == sizeof(index)) { fCurrentChannel = index; printf("Controller::ConnectInterface: selected channel is %d\n", fCurrentChannel); } else { fCurrentChannel = -1; printf("Controller::ConnectInterface: can't get channel control value\n"); } } } ConnectNodes(); return B_OK; }