[leetcode] Construct Binary Tree from Preorder and Inorder Traversal

Construct Binary Tree from Preorder and Inorder Traversal

class Solution {
public:
    TreeNode *buildTreebyIndex(vector<int> &preorder,int preBegin,int preEnd,vector<int> &inorder,int inBegin,int inEnd){
        
        if (preBegin>preEnd||inBegin>inEnd) {
            return nullptr;
        }
        
        int val=preorder[preBegin];
        int index;
        for (int i=inBegin; i<=inEnd; i++) {
            if (val==inorder[i]) {
                index=i;
                break;
            }
        }
        
        int len=index-inBegin;
        TreeNode *pleft=buildTreebyIndex(preorder, preBegin+1, preBegin+len, inorder, inBegin, index-1);
        TreeNode *pright=buildTreebyIndex(preorder, preBegin+len+1, preEnd, inorder, index+1, inEnd);
        
        TreeNode *node=new TreeNode(val);
        node->left=pleft;
        node->right=pright;
        
        return node;
        
    }
    
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
        if (preorder.size()==0) {
            return nullptr;
        }
        return buildTreebyIndex(preorder,0,preorder.size()-1,inorder,0,inorder.size());
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTreeHelper(vector<int>& preorder,vector<int>& inorder,int fromp,int fromi,int length){
        if(length==0){
            return 0;
        }
        TreeNode *root=new TreeNode(preorder[fromp]);
        int i=fromi;
        for(;inorder[i]!=preorder[fromp];++i);//找到对应的root在中序遍历中的位置
        root->left=buildTreeHelper(preorder,inorder,fromp+1,fromi,i-fromi);
        root->right=buildTreeHelper(preorder,inorder,fromp+1+i-fromi,i+1,length-i-1+fromi);//长度更新为length-i-1+fromi
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return buildTreeHelper(preorder,inorder,0,0,preorder.size());//from 0 ...
    }
};

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode helper(int[] preorder,int[] inorder,int fromp,int fromi,int len){
        if(len==0){
            return null;
        }
        TreeNode node=new TreeNode(preorder[fromp]);//(子)树的根
        int i=fromi;
        for(;inorder[i]!=preorder[fromp];++i);//找到对应的根所在的位置
        node.left=helper(preorder,inorder,fromp+1,fromi,i-fromi);
        node.right=helper(preorder,inorder,fromp+1+i-fromi,i+1,len-1-i+fromi);
        return node;
    }
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return helper(preorder,inorder,0,0,preorder.length);
    }
}

测试程序

public class Test1031 {
	
	public static void main(String[] args) {

		Solution st=new Solution();
		int[] preorder={1,2};
		int[] inorder={1,2};
		
		TreeNode node=st.buildTree(preorder, inorder);

		printNode(node);
		
	}
	
	public static void printNode(TreeNode node) {
		if (node == null) {
			return;
		}else{//必须放在else内部，否则会莫名报错
			System.out.println(node.val);

			printNode(node.left);
			printNode(node.right);
		}
		
	}

}