1599832800

# How to speed up a Tree structure traversal in Go?

## đŸŒ³ The tree data structure

Everyone may remember this classical data structure from his studies or more recently from a job interview đŸ˜…

A tree is represented by nodes and each nodes may have 0 or more children nodes. In this article, we will look into the binary tree, a tree where each node may have 0, 1 or 2 children.

A binary tree

In term of vocabulary, the blue node is called the root and the yellow nodes without children are called leafs. The two child nodes are called left and right children.

#go #golang #algorithms #concurrency #programming

1598364000

## Mix Order Traversal of a Binary Tree

Given a Binary Tree consisting of** N** nodes, the task is to print its Mix Order Traversal.

Mix Order Traversal_ is a tree traversal technique, which involves any two of the existing traversal techniques like Inorder, Preorder and Postorder Traversal. Any two of them can be performed or alternate levels of given tree and a mix traversal can be obtained._

Examples:

_Input: _N = 6

_Output: __7 4 5 1 3 6 _

Explanation:

_Inorder-Preorder Mix Traversal is applied to the given tree in the following order: _

_Inorder Traversal is applied at level 0 _

_Preorder Traversal is applied at level 1 _

Inorder Traversal at level 2.

_Output: __4 5 7 1 6 3 _

#data structures #recursion #tree #inorder traversal #postorder traversal #preorder traversal #tree traversals

1599854400

## What's new in the go 1.15

Go announced Go 1.15 version on 11 Aug 2020. Highlighted updates and features include Substantial improvements to the Go linker, Improved allocation for small objects at high core counts, X.509 CommonName deprecation, GOPROXY supports skipping proxies that return errors, New embedded tzdata package, Several Core Library improvements and more.

As Go promise for maintaining backward compatibility. After upgrading to the latest Go 1.15 version, almost all existing Golang applications or programs continue to compile and run as older Golang version.

#go #golang #go 1.15 #go features #go improvement #go package #go new features

1595376000

## Post Order Traversal of Binary Tree in O(N) using O(1) space

Given a Binary Tree, the task is to print the elements in post order using O(N) time complexity and constant space.

``````Input:   1
/   \
2       3
/ \     / \
4   5   6   7
/ \
8   9
Output: 4 8 9 5 2 6 7 3 1

Input:   5
/   \
7       3
/ \     / \
4   11  13  9
/ \
8   4
Output: 4 8 4 11 7 13 9 3 5
``````

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Method 1: Using Morris Inorder Traversal

1. Create a dummy node and make the root as itâ€™s left child.
2. Initialize current with dummy node.
3. While current is not NULL
• If current does not have a left chil traverse the right child, current = current->right
• Otherwise,
1. Find the right most child in the left subtree.
2. If right most childâ€™s right child is NULL
• Make current as the right child of the right most node.
• Traverse the left child, current = current->left
1. Otherwise,
• Set the right most childâ€™s right pointer to NULL.
• From currentâ€™s left child, traverse along the right children until the right most child and reverse the pointers.
• Traverse back from right most child to currentâ€™s left child node by reversing the pointers and printing the elements.
1. Traverse the right child, current = current->right

Below is the diagram showing the right most child in left subtree, pointing to itâ€™s inorder successor.

Below is the diagram which highlights the path 1->2->5->9 and the way the nodes are processed and printed as per the above algorithm.

Below is the implementation of the above approach:

• Java

filter_none

edit

play_arrow

brightness_4

`// Java program to implement`

`// Post Order traversal`

`// of Binary Tree in O(N)`

`// time and O(1) space`

`// Definition of the`

`// binary tree`

`**class**` `TreeNode {`

`**public**` `**int**` `data;`

`**public**` `TreeNode left;`

`**public**` `TreeNode right;`

`**public**` `TreeNode(``**int**` `data)`

`{`

`**this**``.data = data;`

`}`

`**public**` `String toString()`

`{`

`**return**` `data +` `" "``;`

`}`

`}`

`**public**` `**class**` `PostOrder {`

`TreeNode root;`

`// Function to find Post Order`

`// Traversal Using Constant space`

`**void**` `postOrderConstantspace(TreeNode`

`root)`

`{`

`**if**` `(root ==` `**null**``)`

`**return**``;`

`TreeNode current`

`=` `**new**` `TreeNode(-``1``),`

`pre =` `**null**``;`

`TreeNode prev =` `**null**``,`

`succ =` `**null**``,`

`temp =` `**null**``;`

`current.left = root;`

`**while**` `(current !=` `**null**``) {`

`// Go to the right child`

`// if current does not`

`// have a left child`

`**if**` `(current.left ==` `**null**``) {`

`current = current.right;`

`}`

`**else**` `{`

`// Traverse left child`

`pre = current.left;`

`// Find the right most child`

`// in the left subtree`

`**while**` `(pre.right !=` `**null**`

`&& pre.right != current)`

`pre = pre.right;`

`**if**` `(pre.right ==` `**null**``) {`

`// Make current as the right`

`// child of the right most node`

`pre.right = current;`

`// Traverse the left child`

`current = current.left;`

`}`

`**else**` `{`

`pre.right =` `**null**``;`

`succ = current;`

`current = current.left;`

`prev =` `**null**``;`

`// Traverse along the right`

`// subtree to the`

`// right-most child`

`**while**` `(current !=` `**null**``) {`

`temp = current.right;`

`current.right = prev;`

`prev = current;`

`current = temp;`

`}`

`// Traverse back from`

`// right most child to`

`// current's left child node`

`**while**` `(prev !=` `**null**``) {`

`System.out.print(prev);`

`temp = prev.right;`

`prev.right = current;`

`current = prev;`

`prev = temp;`

`}`

`current = succ;`

`current = current.right;`

`}`

`}`

`}`

`}`

`// Driver Code`

`**public**` `**static**` `**void**` `main(String[] args)`

`{`

`/* Constructed tree is as follows:-`

`1 `

`/     \`

`2       3`

`/ \     / \`

`4   5   6   7`

`/ \`

`8   9`

`*/`

`PostOrder tree =` `**new**` `PostOrder();`

`tree.root =` `**new**` `TreeNode(``1``);`

`tree.root.left =` `**new**` `TreeNode(``2``);`

`tree.root.right =` `**new**` `TreeNode(``3``);`

`tree.root.left.left =` `**new**` `TreeNode(``4``);`

`tree.root.left.right`

`=` `**new**` `TreeNode(``5``);`

`tree.root.right.left`

`=` `**new**` `TreeNode(``6``);`

`tree.root.right.right`

`=` `**new**` `TreeNode(``7``);`

`tree.root.left.right.left`

`=` `**new**` `TreeNode(``8``);`

`tree.root.left.right.right`

`=` `**new**` `TreeNode(``9``);`

`tree.postOrderConstantspace(`

`tree.root);`

`}`

`}`

Output:

``````4 8 9 5 2 6 7 3 1
``````

_Time Complexity: _O(N)

Auxiliary Space:_ O(1)_

Method 2: In method 1, we traverse a path, reverse references, print nodes as we restore the references by reversing them again. In method 2, instead of reversing paths and restoring the structure, we traverse to parent node from the current node using the current nodeâ€™s left subtree. This could be faster depending on the tree structure, for example in a right-skewed tree.

The following algorithm and diagrams provide the details of the approach.

#data structures #recursion #tree #inorder traversal #interview-preparation #morris-traversal #postorder traversal

1598227740

## Construct a Maximum Binary Tree from two given Binary Trees

Given two Binary Trees, the task is to create a Maximum Binary Tree from the two given binary trees and print the Inorder Traversal of that tree.

What is the maximum Binary Tree?

_The __maximum binary __is constructed in the following manner: _

_In the case of both the Binary Trees having two corresponding nodes, the maximum of the two values is considered as the node value of the Maximum Binary Tree. _

_If any of the two nodes is NULL and if the other node is not null, insert that value on that node of the Maximum Binary Tree. _

Example:

``````Input:
Tree 1                Tree 2
3                    5
/ \                  / \
2   6                1   8
/                      \   \
20                      2   8
Output: 20 2 2 5 8 8
Explanation:
5
/ \
2   8
/ \   \
20   2   8

To construct the required Binary Tree,
Root Node value: Max(3, 5) = 5
Root->left value: Max(2, 1) = 2
Root->right value: Max(6, 8) = 8
Root->left->left value: 20
Root->left->right value: 2
Root->right->right value: 8

Input:
Tree 1            Tree 2
9                 5
/ \               / \
2   6             1   8
/ \                 \   \
20  3                 2   8
Output:  20 2 3 9 8 8
Explanation:
9
/ \
2   8
/ \   \
20  3   8

``````

#data structures #mathematical #recursion #tree #preorder traversal #tree traversals

1598227320

## Remove all leaf nodes from a Generic Tree or N-ary Tree

Given a Generic tree, the task is to delete the leaf nodes from the tree.

** Examples:**

``````Input:
5
/  /  \  \
1   2   3   8
/   / \   \
15  4   5   6

Output:
5 : 1 2 3
1 :
2 :
3 :

Explanation:
Deleted leafs are:
8, 15, 4, 5, 6

Input:
8
/    |    \
9      7       2
/ | \    |    / / | \ \
4  5 6    10  11 1 2  2 3
Output:
8: 9 7 2
9:
7:
2:
``````

**Approach: **Follow the steps given below to solve the problem

• Take tree into the vector.
• Traverse the tree and check the condition:
• If current node is leaf then
• Delete the leaf from vector
• Else
• Recursively call for every child.

Below is the implementation of the above approach:

#data structures #recursion #tree #n-ary-tree #tree-traversal #data analysis