根据前序遍历-中序遍历结果 来还原一颗二叉树

前序-中序-二叉树还原
对于这样一个二叉树
         A
     /       /
     B       C
   /   /   /   /
   D   E   F   G
  / / / / / / / /
  H I J K M N O P

 

前序遍历的结果是：ABDHIEJKCFMNGOP，我们称之为PRE
中序遍历的结果是：HDIBJEKAMFNCOGP，我们称之为MID
还原的方法是：
 (1)pi指向PRE的第一个字符
 (2)用pi从PRE中取一个字符pc
 (3)查找pc在MID中出现的位置mi
 (4)根据mi确定pc与前一个字符的关系(左孩子/右孩子/没有关系)
 (5)pi+1
 (6)反复重复(2)~(5)步，直到pi超过了PRE的长度

可以看到，问题的关键在于步骤(4)，即如何确定pc与前一个字符的关系。
在这里我们要用到两个辅助结构：
 (1)一个链表，存放Helper结构
 (2)一个Helper结构，用于记录每一个节点在MID中的下标
链表我们可以用STL的list，Helper的结构如下

struct Helper {  TreeNode* node;  int   index; public:  Helper(TreeNode* pNode, int idx)   : node(pNode), index(idx) { } };

当然，二叉树的节点也要有：

struct TreeNode {  char    data;  TreeNode*  lChild;  TreeNode*  rChild; public:  TreeNode(char c) : data(c), lChild(0), rChild(0) { } };

好了，我们一步一步来看看如何解决这个还原二叉树的问题
(1) (A, 7)
     取PRE第一个字符，然后通过Helper放入list中，并构造出一个list的初始环境
      0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
 PRE: A B D H I E J K C F  M  N  G  O  P
 MID: H D I B J E K A M F  N  C  O  G  P
 【list】
 nod  0   A   0
 idx -1   7  15
 cur      ^
 prv
 cur, prv都是指向list中元素的指针，头尾两个元素表示边界
(2) (B, 3)
     取PRE第二个字符，根据list来判定它为谁的左孩子/右孩子
 可以看到，pc=B，其在MID中的下标mi为3，简略为(B, 3)，以后都这么简略
 (B, 3)在(A, 7)左边，因为3 < 7，所以B为A的左孩子，并插入到list中，注意
 cur指针的变动，以后每次插入元素后cur指针都会变动。
      0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
 PRE: A B D H I E J K C F  M  N  G  O  P
 MID: H D I B J E K A M F  N  C  O  G  P
 【list】
 nod  0   B   A   0
 idx -1   3   7  15
 cur      ^
 prv
(3) (D, 1)
     (D, 1)在(B, 3)左边，因为 1 < 3，所以D是B的左孩子，插入list中
 【list】
 nod  0   D   B   A   0
 idx -1   1   3   7  15
 cur      ^
 prv 
(4) (H, 0)
     (H, 0)在(D, 1)左边，H是D的左孩子，插入list中
 【list】
 nod  0   H   D   B   A   0
 idx -1   0   1   3   7  15
 cur      ^
 prv 
(5) (I, 2)
    (I, 2)不在(H, 0)的左边，因为H已经是最左边了，于是我们要prv = cur，cur++
 【list】
 nod  0   H   D   B   A   0
 idx -1   0   1   3   7  15
 cur          ^
 prv      ^
 (I, 2)不在(H, 0),(D, 1)中间，因为0 < 2 < 1不成立，把prv指向的(H, 0)删除
(6) (I, 2)
     (I, 2)不在(D, 1)左边，prv = cur, cur++
 【list】
 nod  0   D   B   A   0
 idx -1   1   3   7  15
 cur          ^
 prv      ^
     (I, 2)在(D, 1),(B, 3)中间，因为1 < 2 < 3，所以I是D的右孩子
 然后把D删除，把I插入，cur指向I
 【list】
 nod  0   I   B   A   0
 idx -1   2   3   7  15
 cur      ^
 prv     
(7) (E, 5)
     (E, 5)不在(I, 2)左边，prv = cur, cur++
 【list】
 nod  0   I   B   A   0
 idx -1   2   3   7  15
 cur          ^
 prv      ^
     结果(E, 5)不在(I, 2),(B, 3)中间，把prv指向的(I, 2)删除
(8) (E, 5)
     (E, 5)不在(B, 3)左边，prv = cur, cur++
 【list】
 nod  0   B   A   0
 idx -1   3   7  15
 cur          ^
 prv      ^
 (E, 5)在(B, 3),(A, 7)中间，于是E是B的右孩子，删除B，插入E，cur指向E
 【list】
 nod  0   E   A   0
 idx -1   5   7  15
 cur      ^
 prv     
(9) (J, 4)
 (J, 4)是在(E, 5)左边的，于是插入(J, 4)，cur指向(J, 4)
 【list】
 nod  0   J   E   A   0
 idx -1   4   5   7  15
 cur      ^
 prv 
(10)(K, 6)
 (K, 6)不在(J, 4)左边，prv = cur, cur++
 (K, 6)不在(J, 4),(E, 5)中间，因此删除(J, 4)
 【list】
 nod  0   E   A   0
 idx -1   5   7  15
 cur      ^
 prv
(11)(K, 6)
 (K, 6)不在(E, 5)左边，prv = cur, cur++
 (K, 6)在(E, 5),(A, 7)中间，于是K是E的右孩子，删除E，插入K，cur指向K
 【list】
 nod  0   K   A   0
 idx -1   6   7  15
 cur      ^
 prv 
***到此为止，A的左子树都已经还原完成了，右子树的还原和左子树一样，以下我只给出
***C的确定方法，其余就省略了。
(12)(C, 11)
     (C, 11)不在(K, 6)左边，prv = cur, cur++
     (C, 11)不在(K, 6),(A, 7)中间，删除(K, 6)
 【list】
 nod  0   A   0
 idx -1   7  15
 cur      ^
 prv 
(13)(C, 11)
     (C, 11)不在(A, 7)左边，prv = cur, cur++
     (C, 11)在(A, 7),(0, 15)中间，于是C是A的右孩子，删除A，插入C，cur指向C
 【list】
 nod  0   C   0
 idx -1   11  15
 cur      ^
 prv
以下省略。。。。 
对了，千万不要忘记在确定X节点是Y节点的左/右孩子后要做相应的链接操作哦。

下面给出算法的C++表示，这里我们用iterator来表示cur, prv指针。我们之所以要用list是
因为list在插入/删除元素后iterator不会失效。还有一点，因为list<>::iterator不支持
random access，所以我们要用prv, cur两个iterator表示一前一后，否则的话直接用cur和
cur + 1就行了，这样的话就简单多了。

然后通过验证可以发现，其二叉树还原后的形态的确是我们希望的形态。

1. #include <iostream>
2. #include <stack>
3. #include <string>
4. #include <list>
5. using namespace std;
7. struct TreeNode {
8.     char            data;
9.     TreeNode*   lChild;
10.     TreeNode*   rChild;
11. public:
12.     TreeNode(char c) : data(c), lChild(0), rChild(0) { }
13. };
16. struct Helper {
17.     TreeNode*   node;
18.     int         index;
19. public:
20.     Helper(TreeNode* pNode, int idx) 
21.         : node(pNode), index(idx) { }
22. };
25. int main() {
26.     void preorderTraversal(TreeNode* pTree);
27.     void inorderTraversal(TreeNode* pTree);
28.     void Pre_Mid_Restore(string pre, string mid, TreeNode*& result);
29.     /*                 A
30.                     /      /
31.                    B       C
32.                  /   /   /   /
33.                  D   E   F   G
34.                 / / / / / / / /
35.                 H I J K M N O P
36.     */
37.     string Preorder1 = "ABDHIEJKCFMNGOP";
38.     string Midorder1 = "HDIBJEKAMFNCOGP";
39.     
40.     string Preorder2 = "ABDFCEG";
41.     string Midorder2 = "BFDAEGC";
43.     string Preorder3 = "ABDCEFG";
44.     string Midorder3 = "DBAFEGC";
45.         
46.     TreeNode* res = 0;
47.     
48.     Pre_Mid_Restore(Preorder1, Midorder1, res);
49.     preorderTraversal(res);
50.     inorderTraversal(res);
51.     
52.     Pre_Mid_Restore(Preorder2, Midorder2, res);
53.     preorderTraversal(res);
54.     inorderTraversal(res);
56.     Pre_Mid_Restore(Preorder3, Midorder3, res);
57.     preorderTraversal(res);
58.     inorderTraversal(res);
59.         
60.     cin.get();
61. }
63. //前序-中序-二叉树还原 
64. void Pre_Mid_Restore(string pre, string mid, TreeNode*& result) {
65.     size_t pi = 0;      //前序遍历所得字符串的下标 
66.     size_t mi = 0;      //中序遍历所得字符串的下标
67.     char pc;                //前序遍历的字符 
68.     
69.     result = new TreeNode(pre[pi]); //前序遍历的第一个字符是根节点 
70.     TreeNode* pNode = 0;
71.     
72.     mi = mid.find(pre[pi]);             //在中序字符串中找到前序字符串的当前字符位置 
73.     
74.     list<Helper> helper;                    
75.     helper.push_back(Helper(0, -1));        
76.     helper.push_back(Helper(result, mi));
77.     helper.push_back(Helper(0, mid.size()));
78.     list<Helper>::iterator cur = helper.begin();
79.     cur++;
80.     /*
81.         下标      -1      7       15
82.         节点      0       A       0
83.         iter                ^
84.     */
85.     for(pi = 1; pi < pre.size(); pi++) {
86.         pc = pre[pi];           //前序字符串的当前字符 
87.         mi = mid.find(pc);  //在中序字符串中的位置 
88.         while(true) {
89.             if (mi < (*cur).index) {    //在左边就是左孩子 
90.                 pNode = new TreeNode(pc);
91.                 (*cur).node->lChild = pNode;
92.                 cur = helper.insert(cur, Helper(pNode, mi));
93.                 break;  
94.             }
95.             else {  //不在左边 
96.                 list<Helper>::iterator prv = cur;
97.                 cur++;
98.                 if((*prv).index < mi && mi < (*cur).index) {    //在中间就是右孩子 
99.                     pNode = new TreeNode(pc);
100.                     (*prv).node->rChild = pNode;
101.                     helper.erase(prv);
102.                     cur = helper.insert(cur, Helper(pNode, mi));
103.                     break;
104.                 }   //不在中间就不是右孩子 
105.                 else {
106.                     helper.erase(prv);
107.                     continue;
108.                 }
109.             }
110.             //some erase work   
111.         }
112.     }
113. }
116. //前序遍历 
117. void preorderTraversal(TreeNode* pTree) {
118.     stack<TreeNode*> treeStack;
119.     do {
120.         while(pTree != 0) {
121.             cout << pTree->data;
122.             if(pTree->rChild != 0) {
123.                 treeStack.push(pTree->rChild);
124.             }
125.             pTree = pTree->lChild;
126.         }
127.         if(!treeStack.empty()) {
128.             pTree = treeStack.top();
129.             treeStack.pop();
130.         }
131.     }while(!treeStack.empty() || pTree != 0);
132.     cout << endl;
133. }
135. //中序遍历 
136. void inorderTraversal(TreeNode* pTree) {
137.     stack<TreeNode*> treeStack;
138.     do {
139.         while(pTree != 0) {
140.             treeStack.push(pTree);
141.             pTree = pTree->lChild;
142.         }
143.         if(!treeStack.empty()) {
144.             pTree = treeStack.top();
145.             treeStack.pop();
146.             cout << pTree->data;
147.             pTree = pTree->rChild;
148.         }
149.     }while(!treeStack.empty() || pTree != 0);
150.     cout << endl;
151. }