*剑指Offer07 重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

 

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

3
/ \
9 20
/ \
15 7

 

前序遍历第一个数即为当前的根节点，再根据该节点的值可以在中序遍历中划分出左子树和右子树，递归下去就可以重建二叉树。

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
13         int n=preorder.size();
14         if(!n) return nullptr;
15         int* ptrpreorder=&preorder[0];
16         int* ptrinorder=&inorder[0];
17         return Construct(ptrpreorder,ptrpreorder+n-1,ptrinorder,ptrinorder+n-1);
18     }
19 
20     TreeNode* Construct(int* startpreorder, int* endpreorder, int* startinorder, int*endinorder){
21         int rootval=startpreorder[0];
22         TreeNode* curroot= new TreeNode();
23         curroot->val=rootval;
24         curroot->left=curroot->right=nullptr;
25 
26         if(startpreorder==endpreorder){
27             if(startinorder==endinorder && *startpreorder==*startinorder)
28                 return curroot;
29         }
30 
31         int* rootinorder=startinorder;
32         while(rootinorder<=endinorder && *rootinorder!=rootval)
33             rootinorder++;
34         
35         int leftlen=0,rightlen=0;
36         leftlen=rootinorder-startinorder;
37         int* leftendpreorder=startpreorder+leftlen;
38         if(leftlen){
39             curroot->left=Construct(startpreorder+1,leftendpreorder,startinorder,rootinorder-1);
40         }
41 
42         if(rootinorder!=endinorder){
43             curroot->right=Construct(leftendpreorder+1,endpreorder,rootinorder+1,endinorder);
44         }
45         return curroot;
46     }
47 };

 

第二次做，加入了用全局变量记录错误信息。

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 
11 enum{Valid,InValid};
12 int g_buildTree=Valid;
13 
14 class Solution {
15 public:
16     TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
17         int n=preorder.size();
18         if(n!=inorder.size() || !n){
19             g_buildTree=InValid;
20             return nullptr;
21         }
22         TreeNode* root= recursive_build(preorder,inorder,0,n-1,0,n-1);
23         return root;
24     }
25 
26     TreeNode* recursive_build(vector<int>& preorder, vector<int>& inorder, int startpre, int endpre, int startin, int endin){
27         if(startpre==endpre){
28             TreeNode* leaf=new TreeNode(preorder[startpre]);
29             return leaf;
30         }
31 
32         TreeNode* curroot=new TreeNode(preorder[startpre]);
33         int leftlen=0;
34         for(int i=startin;i<=endin;++i){
35             if(inorder[i]==preorder[startpre]){
36                 leftlen=i-startin;
37                 break;
38             }
39         }
40 
41         if(leftlen){      
42             curroot->left=recursive_build(preorder,inorder,startpre+1,startpre+leftlen,startin,startin+leftlen-1);
43         }
44         if(startpre+leftlen!=endpre){
45             curroot->right=recursive_build(preorder,inorder,startpre+leftlen+1,endpre,startin+leftlen+1,endin);
46         }
47 
48         return curroot;
49     }
50 
51 
52 
53 };

 

posted @ 2020-07-02 11:34  __rookie  阅读(122)  评论(0)  编辑  收藏  举报