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;
}
