void TR::ILValidator::checkSoundness(TR::TreeTop *start, TR::TreeTop *stop) { soundnessRule(start, start != NULL, "Start tree must exist"); soundnessRule(stop, !stop || stop->getNode() != NULL, "Stop tree must have a node"); TR::NodeChecklist treetopNodes(comp()), ancestorNodes(comp()), visitedNodes(comp()); // Can't use iterators here, because those presuppose the IL is sound. Walk trees the old-fashioned way. // for (TR::TreeTop *currentTree = start; currentTree != stop; currentTree = currentTree->getNextTreeTop()) { soundnessRule(currentTree, currentTree->getNode() != NULL, "Tree must have a node"); soundnessRule(currentTree, !treetopNodes.contains(currentTree->getNode()), "Treetop node n%dn encountered twice", currentTree->getNode()->getGlobalIndex()); treetopNodes.add(currentTree->getNode()); TR::TreeTop *next = currentTree->getNextTreeTop(); if (next) { soundnessRule(currentTree, next->getNode() != NULL, "Tree after n%dn must have a node", currentTree->getNode()->getGlobalIndex()); soundnessRule(currentTree, next->getPrevTreeTop() == currentTree, "Doubly-linked treetop list must be consistent: n%dn->n%dn<-n%dn", currentTree->getNode()->getGlobalIndex(), next->getNode()->getGlobalIndex(), next->getPrevTreeTop()->getNode()->getGlobalIndex()); } else { soundnessRule(currentTree, stop == NULL, "Reached the end of the trees after n%dn without encountering the stop tree n%dn", currentTree->getNode()->getGlobalIndex(), stop? stop->getNode()->getGlobalIndex() : 0); checkNodeSoundness(currentTree, currentTree->getNode(), ancestorNodes, visitedNodes); } } }
std::vector<int> primPrincipal(Graph & G, float & length, int v) { int size = G->GetNodes(); std::vector<float> distances (size,inf); std::vector<bool> visitedNodes (size,false); std::vector<int> parents (size,-1); std::deque<QueueItem> queue; for(int i=0; i<size; i++) { QueueItem q; q.VertexID = i+1; q.distance = inf; queue.push_back(q); } distances[v-1] = 0; visitedNodes[v-1] = true; while(!queue.empty()) { std::sort(queue.begin(), queue.end(), sortQueue); QueueItem u = queue.front(); queue.pop_front(); SnapEdge EI; if(parents[u.VertexID-1] != -1) { TNodeEDatNet<TInt, TFlt>::TEdgeI EI = G->GetEI(parents[u.VertexID-1],u.VertexID); length+=(float)EI.GetDat(); } visitedNodes[u.VertexID-1] = true; SnapNode NI = G->GetNI(u.VertexID); for (int e = 0; e < NI.GetOutDeg(); e++) { SnapEdge EI = G->GetEI(u.VertexID,NI.GetOutNDat(e)); int outNode = NI.GetOutNDat(e); float edgeWeight = (float)EI.GetDat(); if(!visitedNodes[outNode-1] && distances[outNode-1] > edgeWeight) { parents[outNode-1] = u.VertexID; distances[outNode-1] = edgeWeight; for(int i=0; i< queue.size(); i++) { if(queue[i].VertexID == outNode) queue[i].distance = edgeWeight; } } } } return parents; }
void TR::SoundnessRule::validate(TR::ResolvedMethodSymbol *methodSymbol) { TR::TreeTop *start = methodSymbol->getFirstTreeTop(); TR::TreeTop *stop = methodSymbol->getLastTreeTop(); checkSoundnessCondition(start, start != NULL, "Start tree must exist"); checkSoundnessCondition(stop, !stop || stop->getNode() != NULL, "Stop tree must have a node"); TR::NodeChecklist treetopNodes(comp()), ancestorNodes(comp()), visitedNodes(comp()); /* NOTE: Can't use iterators here, because iterators presuppose that the IL is sound. */ for (TR::TreeTop *currentTree = start; currentTree != stop; currentTree = currentTree->getNextTreeTop()) { checkSoundnessCondition(currentTree, currentTree->getNode() != NULL, "Tree must have a node"); checkSoundnessCondition(currentTree, !treetopNodes.contains(currentTree->getNode()), "Treetop node n%dn encountered twice", currentTree->getNode()->getGlobalIndex()); treetopNodes.add(currentTree->getNode()); TR::TreeTop *next = currentTree->getNextTreeTop(); if (next) { checkSoundnessCondition(currentTree, next->getNode() != NULL, "Tree after n%dn must have a node", currentTree->getNode()->getGlobalIndex()); checkSoundnessCondition(currentTree, next->getPrevTreeTop() == currentTree, "Doubly-linked treetop list must be consistent: n%dn->n%dn<-n%dn", currentTree->getNode()->getGlobalIndex(), next->getNode()->getGlobalIndex(), next->getPrevTreeTop()->getNode()->getGlobalIndex()); } else { checkSoundnessCondition(currentTree, stop == NULL, "Reached the end of the trees after n%dn without encountering the stop tree n%dn", currentTree->getNode()->getGlobalIndex(), stop? stop->getNode()->getGlobalIndex() : 0); checkNodeSoundness(currentTree, currentTree->getNode(), ancestorNodes, visitedNodes); } } }
vector<string> binaryTreePaths(TreeNode* root) { vector<string> paths; // If root is NULL, return an empty path vector immediately. if (root == nullptr) { return paths; } // pathVal is a vector of TreeNode values along a path // starting from root. vector<int> pathVal({ root->val }); // st is the stack used for the depth-first search. stack<TreeNode*> st; st.push(root); // visitedNodes keeps all the nodes which have been visited // during the depth-first search. In other words, it keeps // all the nodes which have ever been pushed into the stack. unordered_set<TreeNode*> visitedNodes({ root }); // Do the depth-first search until the stack is empty. while (!st.empty()) { TreeNode *curr = st.top(); if ((curr->left == nullptr) && (curr->right == nullptr)) { // curr is a leaf, so the current path is a path from // root to a leaf and add it to paths. paths.push_back(GetPathStringFromNums(pathVal)); // Remove the leaf node from pathVal which will end at // the parent node of curr. pathVal.pop_back(); st.pop(); } else { // curr is not leaf, so we need to go down at least one // level. // First we try pushing the left child if it hasn't // been visited. if (curr->left != nullptr) { auto itLeft = visitedNodes.find(curr->left); if (itLeft == visitedNodes.end()) { st.push(curr->left); pathVal.push_back(curr->left->val); visitedNodes.insert(curr->left); continue; } } // We reach here because either the left child doesn't // exist or the left child has been visited. Then we try // pushing the right child if it hasn't been visited. if (curr->right != nullptr) { auto itRight = visitedNodes.find(curr->right); if (itRight == visitedNodes.end()) { st.push(curr->right); pathVal.push_back(curr->right->val); visitedNodes.insert(curr->right); continue; } } // The nodes in the subtree below curr have all been // visited, so remove curr from pathVal which will end // at the parent node of curr. pathVal.pop_back(); st.pop(); } } return paths; }