flyinghearts《编程之美》读书笔记连载（15）

 3.9_重建二叉树

 对根节点a以及先序遍历次序P和中序遍历次序I，查找a在I中的位置，将I分为两部分，左边部分的元素都在a的左子树上，右边的元素都在a的右子树上，因而可以确定a的左子树节点数和a的右子树节点数，再结合P，可以确定a的左孩子和右孩子，以及各个孩子的先序和中序遍历次序。

由于已经知道节点数，可以事先分配好内存，可以按先序遍历次序连续存放节点。 

view plain copy to clipboard print ?

1. struct Node {  
2.   Node* left;  
3.   Node* right;  
4.   char data;  
5. };  
6.   
7. void rebuild(char preorder[], char inorder[], Node result[], size_t size)  
8. {  
9.   result->data = *preorder;  
10.   result->left=NULL;  
11.   result->right=NULL;  
12.   char *p = inorder;  
13.   size_t left_size=0;  
14.   while (left_size<size && *p++!=*preorder) ++left_size;  
15.   assert (left_size<size);  
16.   size_t right_size = size-1-left_size;  
17.   if (left_size) {  
18.     result->left=result+1;  
19.     rebuild(preorder+1, inorder, result+1, left_size);  
20.   }  
21.   if (right_size) {  
22.     result->right=result+left_size+1;  
23.     rebuild(preorder+left_size+1, inorder+left_size+1,  
24.             result+left_size+1, right_size);  
25.   }  
26. }  

  上面的代码，栈深度是O(n)，有可能出现栈溢出，可以修改代码，减少一次递归调用，实现栈深度为O(lg n)。

 view plaincopy to clipboardprint?

1. void rebuild2(char preorder[], char inorder[], Node result[], size_t size)  
2. {  
3.   
4.   while (1){  
5.     result->data = *preorder;  
6.     result->left=NULL;  
7.     result->right=NULL;  
8.     char *p = inorder;  
9.     size_t left_size=0;  
10.     while (left_size<size && *p++!=*preorder) ++left_size;  
11.     assert (left_size<size);  
12.     if (size==1) return;  
13.     size_t right_size = size-1-left_size;  
14.   
15.     if (left_size<right_size) {  
16.       if (left_size) {  
17.         result->left=result+1;  
18.         rebuild2(preorder+1, inorder, result+1, left_size);  
19.       }  
20.       result->right=result+left_size+1;  
21.       preorder += left_size+1;  
22.       inorder += left_size+1;  
23.       result += left_size+1;  
24.       size = right_size;  
25.     } else {  
26.       if (right_size) {  
27.         result->right=result+left_size+1;  
28.         rebuild2(preorder+left_size+1, inorder+left_size+1,  
29.                 result+left_size+1, right_size);  
30.       }  
31.       if (left_size) {  
32.         result->left=result+1;        
33.         ++preorder;  
34.         ++result;  
35.         size = left_size;  
36.       }  
37.     }  
38.   }  
39. }  

 

 书上的代码（P246）： 

view plain copy to clipboard print ?

1. NODE* pTemp = new NODE;  
2. pTemp -> chValue = *pPreOrder;  
3. pTemp -> pLeft = NULL;  
4. pTemp -> pRight = NULL;  
5.   
6. // 如果节点为空，把当前节点复制到根节点  
7. if(*pRoot == NULL)  
8. {  
9.      *pRoot = pTemp;  
10. }  

 

  可能引起内存泄漏（当*pRoot!=NULL，新申请的内存没释放），注释也不对（不是复制节点，而是更改指针指向新建的节点）。另外，频繁的new，极有可能会产生内存碎片。当节点很小时，内存浪费很严重（每new一次都要额外分配空间储存相关信息）。

原贴地址：http://blog.csdn.net/flyinghearts/archive/2010/05/31/5638123.aspx