void postOrderTraversal(BinaryTreeNode* node) { if (node != nullptr) { postOrderTraversal(node->left); // visit(node); postOrderTraversal(node->right); } }
void postOrderTraversal(struct TreeNode *root) { if(root != NULL) { postOrderTraversal(root->left); postOrderTraversal(root->right); printf(" %d ", root->data); } }
void BST<T>::postOrderTraversal(Node<T>* root) { if(root != 0) { postOrderTraversal(root->getLeftChild()); postOrderTraversal(root->getRightChild()); std::cout << root->getValue() << std::endl; } }
void AVL<T>::postOrderTraversal(Node<T>* curr) { if (curr != 0) { postOrderTraversal(curr->getLeftChild()); postOrderTraversal(curr->getRightChild()); std::cout << curr->getValue() << ", " << curr->getBalance() << std::endl; } }
void postOrderTraversal( avlTreeNode* root) { if( root ) { postOrderTraversal( root -> leftTree ); postOrderTraversal( root -> rightTree ); printf("%d ",root -> data ); } }
/// Function to Traverse the Binary tree using Post-Order Traversal Technique void postOrderTraversal(struct bt_node *node) { if (node != NULL) { postOrderTraversal(node->lchild); postOrderTraversal(node->rchild); printf("%d\n",node->data); } }
void postOrderTraversal(TreeNode *node, int &maxPathSum) { if (node == NULL) { return; } postOrderTraversal(node->left, maxPathSum); postOrderTraversal(node->right, maxPathSum); int leftVal = (node->left == NULL? 0: node->left->val); int rightVal = (node->right == NULL? 0: node->right->val); int currentNodeVal = node->val; if (max(leftVal, rightVal) > 0) { node->val += max(leftVal, rightVal); } maxPathSum = max(maxPathSum, max(node->val, currentNodeVal + leftVal + rightVal)); }
string postOrderTraversal(TreeNode* node, unordered_map<string, int>* lookup, vector<TreeNode*> *result) { if (!node) { return ""; } string s = "("; s += postOrderTraversal(node->left, lookup, result); s += to_string(node->val); s += postOrderTraversal(node->right, lookup, result); s += ")"; if ((*lookup)[s] == 1) { result->emplace_back(node); } ++(*lookup)[s]; return s; }
int evaluate(ParseTreeNode *p_root){ ParseTreeNode *result_node; int val; initializeStack(); initializeQueue(); /* So that the tree will not be changed */ postOrderTraversal(p_root, &evaluatorHelper); result_node = pop(); val = *(result_node->m_token->m_data_container->m_int); /* Free the resources */ while(!isQueueEmpty()){ result_node = dequeue(); free(result_node->m_token->m_data_container); result_node->m_token->m_data_container = NULL; free(result_node->m_token); result_node->m_token = NULL; free(result_node); result_node = NULL; } return val; }
int maxPathSum(TreeNode *root) { // Start typing your C/C++ solution below // DO NOT write int main() function if (root==NULL) return 0; queue<TreeNode*> q; postOrderTraversal (root, q); int max_sum = -INT_MAX; map <TreeNode*, int> m;//Record max path sum, which has one end at the key node while (!q.empty()){ TreeNode * n = q.front(); q.pop(); if (!n->left && !n->right){//leaf m[n] = n->val; max_sum = max(max_sum, m[n]); }else{ int left_sum = 0, right_sum = 0; if (n->left){ left_sum = max(m[n->left], 0); } if (n->right){ right_sum = max(m[n->right], 0); } m[n] = n->val + max(left_sum, right_sum); max_sum = max(max_sum, n->val + left_sum + right_sum); } } return max_sum; }
int maxPathSum(TreeNode *root) { if (root == NULL) { return 0; } int maxPathSum = INT_MIN; postOrderTraversal(root, maxPathSum); return maxPathSum; }
void AVL<T>::print() { /* cout << "pre order traversal:" << endl; preOrderTraversal(root); cout << "in order traversal:" << endl; inOrderTraversal(root); */ cout << "post order traversal:" << endl; postOrderTraversal(root); }
void printTree(avlTreeNode* root) { printf("\n\n**********************************\n\n"); printf("\nInOrder Traversal\n"); inOrderTraversal(root); printf("\nPreOrder Traversal\n"); preOrderTraversal(root); printf("\nPostOrder Traversal\n"); postOrderTraversal(root); printf("\t\t[%d]\n",root->height); }
int main() { Node *root = newNode(20); root->left = newNode(8); root->left->left = newNode(4); root->left->right = newNode(12); root->left->right->left = newNode(10); root->left->right->right = newNode(14); root->right = newNode(22); int height = treeHeight(root); printf("Tree Height : %d\n", height); printf("preOrderTraversal :\n"); preOrderTraversal(root); printf("\n"); printf("inOrderTraversal :\n"); inOrderTraversal(root); printf("\n"); printf("postOrderTraversal :\n"); postOrderTraversal(root); printf("\n"); Node *anNode = findLowestCommonAncestor(root, 4, 14); printf("findLowestCommonAncestor 4 and 14 is : %d\n", anNode->data); int count = traverse(root, 0, NULL); printf("traverse count = %d\n", count); Node *newRoot = heapifyBinaryTree(root); return 0; }
int main () { binaryTreeInsert(4); binaryTreeInsert(2); binaryTreeInsert(7); binaryTreeInsert(10); binaryTreeInsert(5); binaryTreeInsert(0); binaryTreeInsert(3); binaryTreeInsert(-5); binaryTreeInsert(1); printf(" Preorder Traversal :\n"); preOrderTraversal(root); printf("\n Inorder Traversal:\n"); inOrderTraversal(root); printf("\n Postorder Traversal:\n"); postOrderTraversal(root); printf("\n Breadth Traversal:\n"); breadthTraversal(root); }
vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) { unordered_map<string, int> lookup; vector<TreeNode*> result; postOrderTraversal(root, &lookup, &result); return result; }
int main() { // create the tree struct TreeNode *root = NULL; root = (struct TreeNode *)malloc(sizeof(struct TreeNode)); root->data = 1; root->left = (struct TreeNode *)malloc(sizeof(struct TreeNode)); (root->left)->data = 2; (root->left)->right = NULL; (root->left)->left = (struct TreeNode *)malloc(sizeof(struct TreeNode)); ((root->left)->left)->data = 4; ((root->left)->left)->left = NULL; ((root->left)->left)->right = NULL; (root->left)->right = (struct TreeNode *)malloc(sizeof(struct TreeNode)); ((root->left)->right)->data = 5; ((root->left)->right)->left = NULL; ((root->left)->right)->right = NULL; (root->right) = (struct TreeNode *)malloc(sizeof(struct TreeNode)); (root->right)->data = 3; (root->right)->right = NULL; (root->right)->left = (struct TreeNode *)malloc(sizeof(struct TreeNode)); ((root->right)->left)->data = 6; ((root->right)->left)->left = NULL; ((root->right)->left)->right = NULL; (root->right)->right = (struct TreeNode *)malloc(sizeof(struct TreeNode)); ((root->right)->right)->data = 7; ((root->right)->right)->left = NULL; ((root->right)->right)->right = NULL; printf(" 1 \n"); printf(" / \\ \n"); printf(" 2 3 \n"); printf(" / \\ / \\ \n"); printf("4 5 6 7 \n"); printf("\nPreOrder Traversal\n"); preOrderTraversal(root); printf("\n"); printf("InOrder Traversal\n"); inOrderTraversal(root); printf("\n"); printf("PostOrder Traversal\n"); postOrderTraversal(root); printf("\n"); printf("LevelOrder Traversal\n"); struct TreeNode *temp = NULL; struct Queue *queue = createQueue(); enqueue(queue, root); while(queue->front != NULL) { temp = dequeue(queue); printf(" %d ", temp->data); if(temp->left != NULL) { enqueue(queue, temp->left); } if(temp->right != NULL) { enqueue(queue, temp->right); } } printf("\n"); destroyQueue(&queue); return 0; }
int testBinarySearchTree(void) { Tree *head = NULL; Tree *singleNodeTree = malloc(sizeof(Tree)); Tree *test[2]; if(singleNodeTree == NULL) { exit(EXIT_FAILURE); } singleNodeTree->value = 100; singleNodeTree->left = NULL; singleNodeTree->right = NULL; printf("Start Test of Binary Search Tree.\n"); printf("Initial contents of the tree:\n"); print_ascii_tree(head); printf("\nadd() 5 to the tree\n"); head = addToTree(head, 5); print_ascii_tree(head); printf("\nadd() 2 to the tree\n"); head = addToTree(head, 2); print_ascii_tree(head); printf("\nadd() 12 to the tree\n"); head = addToTree(head, 12); print_ascii_tree(head); printf("\nadd() 1 to the tree\n"); head = addToTree(head, 1); print_ascii_tree(head); printf("\nadd() 8 to the tree\n"); head = addToTree(head, 8); print_ascii_tree(head); printf("\nadd() 4 to the tree\n"); head = addToTree(head, 4); print_ascii_tree(head); printf("\nadd() 3 to the tree\n"); head = addToTree(head, 3); print_ascii_tree(head); printf("\nadd() 10 to the tree\n"); head = addToTree(head, 10); print_ascii_tree(head); printf("\nadd() 9 to the tree\n"); head = addToTree(head, 9); print_ascii_tree(head); printf("\nadd() 11 to the tree\n"); head = addToTree(head, 11); print_ascii_tree(head); printf("\nadd() 7 to the tree\n"); head = addToTree(head, 7); print_ascii_tree(head); if( (test[0] = findInTree(head, 3)) == NULL) { printf("\nfind(3) = Value Not Found\n"); } else { printf("\nfind(3) = %d\n", test[0]->value); } if( (test[0] = findInTree(head, 7)) == NULL) { printf("\nfind(7) = Value Not Found\n"); } else { printf("\nfind(7) = %d\n", test[0]->value); } if( (test[0] = findInTree(head, 4)) == NULL) { printf("\nfind(4) = Value Not Found\n"); } else { printf("\nfind(4) = %d\n", test[0]->value); } findParentInTree(head, head, 3, test); if( test[1] == NULL) { printf("\nfindParentOfNode(3) = Value Not Found\n"); } else { printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value); } findParentInTree(head, head, 5, test); if( test[1] == NULL) { printf("\nfindParentOfNode(5) = Value Not Found\n"); } else { printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value); } findParentInTree(head, head, 2, test); if( test[1] == NULL) { printf("\nfindParentOfNode(2) = Value Not Found\n"); } else { printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value); } findParentInTree(head, head, 9, test); if( test[1] == NULL) { printf("\nfindParentOfNode(9) = Value Not Found\n"); } else { printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value); } printf("Depth of the tree = %d\n", getTreeDepth(head, 0)); inOrderTraversal(head); preOrderTraversal(head); postOrderTraversal(head); breadthFirstSearch(head); /* Delete Order: 1, 3, 12, 8, 5 */ printf("\nbefore removing any items\n"); print_ascii_tree(head); printf("\nremove() 1 from the tree\n"); head = removeFromTree(head, 1); print_ascii_tree(head); printf("\nremove() 3 from the tree\n"); head = removeFromTree(head, 3); print_ascii_tree(head); printf("\nremove() 12 from the tree\n"); head = removeFromTree(head, 12); print_ascii_tree(head); printf("\nremove() 8 from the tree\n"); head = removeFromTree(head, 8); print_ascii_tree(head); printf("\nremove() 5 from the tree\n"); head = removeFromTree(head, 5); print_ascii_tree(head); printf("\nremove() 11 from the tree\n"); head = removeFromTree(head, 11); print_ascii_tree(head); printf("Depth of the tree = %d\n", getTreeDepth(head, 0)); inOrderTraversal(head); breadthFirstSearch(head); printf("\nsinglNodeTests start here: \n"); print_ascii_tree(singleNodeTree); inOrderTraversal(singleNodeTree); printf("\n remove() 1 from tree\n"); if(removeFromTree(singleNodeTree, 1) == NULL) { printf("Node Not Found, nothing removed\n"); } printf("Depth of the singleNodeTree = %d\n", getTreeDepth(singleNodeTree, 0)); printf("\n remove() 100 from tree\n"); singleNodeTree = removeFromTree(singleNodeTree, 100); printf("Depth of the singleNodeTree = %d\n", getTreeDepth(singleNodeTree, 0)); return EXIT_SUCCESS; }
void postOrderTraversal(Node *root) { if(root == NULL) return; postOrderTraversal(root->left); postOrderTraversal(root->right); printf("%d\t", root->data); }
void postOrderTraversal(TreeNode * root, queue<TreeNode*> & q){ if (root == NULL) return; postOrderTraversal (root->left, q); postOrderTraversal (root->right, q); q.push(root); }
int main() { printf("Start\n"); printf("Initializing stack\n"); Stack* stack = (Stack *) malloc(sizeof (Stack)); initStack(stack); int i; for (i = 0; i < 10; i++) { pushStack(stack, initIntElem(i)); int *k = inspectStack(stack); printf("Pushed %d\n", *k); } while (!isEmptyStack(stack)) { int *k = popStack(stack); printf("Popped %d\n", *k); free(k); } printf("Freeing stack\n"); clearStack(stack); free(stack); printf("Initializing queue\n"); Queue *queue = (Queue *) malloc(sizeof (Queue)); initQueue(queue); for (i = 0; i < 10; i++) { enqueue(queue, initIntElem(i)); int *k = inspectLastQueue(queue); printf("Enqueued %d\n", *k); } while (!isEmptyQueue(queue)) { int *k = dequeue(queue); printf("Dequeued %d\n", *k); free(k); } printf("Freeing queue\n"); clearQueue(queue); free(queue); printf("End\n"); BinaryTree *a = (BinaryTree*)malloc(sizeof(BinaryTree)); a->root = NULL; insertBinaryTree(a,initIntElem(10)); insertBinaryTree(a,initIntElem(5)); insertBinaryTree(a,initIntElem(12)); insertBinaryTree(a,initIntElem(7)); insertBinaryTree(a,initIntElem(8)); insertBinaryTree(a,initIntElem(19)); preOrderTraversal(a); printf("\n"); postOrderTraversal(a); printf("\n"); inOrderTraversal(a); printf("\n"); breadthFirstTraversal(a); return 0; }