Reconstruct a binary tree through its pre- and mid-order traversal sequences

When first learned binary tree at school, given a binary tree, there are three basic orders to traverse all its nodes (in fact there are more than three orders): pre-order, mid-order, and post-order. Suppose that we have pre-order and mid-order at hand, the binary tree can be reconstructed and its post-order traversal can be generated (Notice that post-order and mid-order can also provide enough information to determine the binary tree whereas only pre-order and post-order cannot, because such situation that a non-leaf node has only one subtree exists and it cannot be determined whether the subtree is left child or right child). Below is the c++ implementation.

 

1. #include <iostream>
2. #include <assert.h>
3. using namespace std;
5. template <typename T>
6. struct Node {
7.   T data;
8.   Node * left;
9.   Node * right;
10. };
12. // Find the index of an element in a sequence within a certain length.
13. template <typename T>
14. int IndexOf(T* sequence, int length, T element) {
15.   for(int i = 0; i < length; ++i) {
16.     if(element == sequence[i]) {
17.       return i;
18.     }
19.   }
20.   return -1;
21. }
23. // Reconstruct a binary tree through its pre- and mid-order traversal.
24. template <typename T>
25. Node<T>* TreeReconstruction(T* preOrder, T* midOrder, int length) {
26.   if(length == 0) {
27.     return NULL;
28.   }
29.   Node<T>* root = new Node<T>();
30.   root->data = preOrder[0];
31.   int index = IndexOf(midOrder, length, preOrder[0]); // Find index of root in mid-order sequence.
32.   assert(index != -1);
33.   root->left = TreeReconstruction(preOrder + 1, midOrder, index); // Reconstruct root's left child.
34.   root->right = TreeReconstruction(preOrder + 1 + index, midOrder +1 + index, length - 1 - index); //Reconstruct root's right child.
35.   return root;
36. }
38. // Print the post-order traversal of a binary tree.
39. template <typename T>
40. void PrintPostOrder(Node<T>* root) {
41.   if(root == NULL) {
42.     return;
43.   }
44.   PrintPostOrder(root->left);
45.   PrintPostOrder(root->right);
46.   cout << root->data;
47. }
49. // Test code: main.
50. int main(int argc, char ** argv) {
51.   int pre[8] = {1,2,4,5,7,8,3,6};
52.   int mid[8] = {4,2,7,5,8,1,3,6};
53.   Node<int>* tree = TreeReconstruction(pre, mid, 8);
54.   PrintPostOrder(tree);
55.   cout << endl;
56.   return 0;
57. }

The command line prints:

47852631

 

It works. As you see, recursive programming can be very helpful and useful when a data structure can be viewed as consisting of some similar substructures.