Create a tree based on the first and middle order of the tree

We only know that the first sequence and the latter sequence cannot find the unique tree, so we will not discuss it.

 

[CPP]View plaincopy

1. # Include <iostream>
2. # Include <cstdio>
3. # Include <cstring>
4. Using namespace STD;
6. Struct binarytreenode
7. {
8. Char C;
9. Binarytreenode * lchild, * rchild;
10. Binarytreenode ()
11. {
12. Lchild = NULL, rchild = NULL;
13. }
14. };
15. Struct binarytreenode * root1, * root2;
17. Char preorder [100], inorder [100], postorder [100];
19. Void presearch (binarytreenode * root) // first traverse the tree
20. {
21. If (root! = NULL)
22. {
23. Printf ("% C", root-> C );
24. Presearch (root-> lchild );
25. Presearch (root-> rchild );
26. }
27. Return;
28. }
30. Void midsearch (binarytreenode * root) // The middle-order traversal tree.
31. {
32. If (root! = NULL)
33. {
34. Midsearch (root-> lchild );
35. Printf ("% C", root-> C );
36. Midsearch (root-> rchild );
37. }
38. Return;
39. }
41. Void postsearch (binarytreenode * root) // traverse the tree in descending order
42. {
43. If (root! = NULL)
44. {
45. Postsearch (root-> lchild );
46. Postsearch (root-> rchild );
47. Printf ("% C", root-> C );
48. }
49. Return;
50. }
52. Void buildtreefrompreandmid (binarytreenode * & root, int LL, int LR, int Len, Int & now) // calculate the tree in the middle and first order
53. {
54. Root = new binarytreenode ();
55. Root-> C = * (preorder + now );
56. Int Pos = (INT) (strchr (inorder, * (preorder + now)-inorder); // you can specify the position where a character first appears in a string.
57. Now ++;
58. If (now> = Len)
59. Return;
60. If (POS-1> = LL)
61. {
62. Binarytreenode * t = new binarytreenode ();
63. Root-> lchild = T;
64. Buildtreefrompreandmid (root-> lchild, ll, pos-1, Len, now );
65. }
66. If (Pos + 1 <= LR)
67. {
68. Binarytreenode * t = new binarytreenode ();
69. Root-> rchild = T;
70. Buildtreefrompreandmid (root-> rchild, POS + 1, LR, Len, now );
71. }
72. }
74. Void buildtreefrompostandmid (binarytreenode * & root, int LL, int LR, int Len, Int & now) // calculate the tree in the middle and back order
75. {
76. Root = new binarytreenode ();
77. Root-> C = * (postorder + now );
78. Int Pos = (INT) (strchr (inorder, * (postorder + now)-inorder );
79. Now --;
80. If (now <0)
81. Return;
82. If (Pos + 1 <= LR)
83. {
84. Binarytreenode * t = new binarytreenode ();
85. Root-> rchild = T;
86. Buildtreefrompostandmid (root-> rchild, POS + 1, LR, Len, now );
87. }
88. If (POS-1> = LL)
89. {
90. Binarytreenode * t = new binarytreenode ();
91. Root-> lchild = T;
92. Buildtreefrompostandmid (root-> lchild, ll, pos-1, Len, now );
93. }
94. }
96. // Release a binary tree
97. Inline void deletebinarytree (binarytreenode * & root)
98. {
99. If (Root)
100. {
101. Deletebinarytree (root-> lchild); // release the left subtree
102. Deletebinarytree (root-> rchild); // release the right subtree
103. Delete root; // release the root node
104. }
105. }
107. Int main (void)
108. {
109. Gets (preorder );
110. Gets (inorder );
111. // Gets (postorder );
112. Int now = 0;
113. Buildtreefrompreandmid (root1, 0, strlen (preorder)-1, strlen (preorder), now );
115. // Int now2 = strlen (postorder)-1;
116. // Buildtreefrompostandmid (root2, 0, strlen (postorder)-1, strlen (postorder), now2 );
118. Postsearch (root1 );
119. Puts ("");
120. Deletebinarytree (root1 );
121. /* Presearch (root2 );
122. Puts ("");
123. Deletebinarytree (root2 );*/
124. Return 0;
125. }