重构二叉树

最新推荐文章于 2024-10-31 01:07:31 发布

mimota

最新推荐文章于 2024-10-31 01:07:31 发布

阅读量361

点赞数 1

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/mimota/article/details/85986600

本文介绍了一种使用前序和中序遍历重构二叉树的方法，通过递归思想，从前序中找到根节点，并根据根节点在中序的位置划分左右子树，实现树的重构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

import java.util.ArrayList;


//Definition for binary tree
class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode(int x) { val = x; }
 }


public class Father {
    
    public TreeNode reC(ArrayList<Integer> pre_list, ArrayList<Integer> in_list){
        if(pre_list.size() > 0){
            
            int g = pre_list.get(0);
            TreeNode t = new TreeNode(g);
            int i = 0;
                
            for(; i < in_list.size(); i++){
                if( in_list.get(i) == g){
                    break;
                }
            }
            
            ArrayList<Integer> in_list_left = new ArrayList<Integer>();
            ArrayList<Integer> in_list_right = new ArrayList<Integer>();
            
            for(int j = 0; j < i; j++){
                in_list_left.add(in_list.get(j));
            }
            
            for(int j = i + 1; j < in_list.size(); j++){
                in_list_right.add(in_list.get(j));
            }
            
            ArrayList<Integer> pre_list_left = new ArrayList<Integer>();
            ArrayList<Integer> pre_list_right = new ArrayList<Integer>();
            
            for(int j = 0; j < pre_list.size(); j++){
                for(int k = 0; k < in_list_left.size(); k++){
                    if(pre_list.get(j) == in_list_left.get(k)){
                        pre_list_left.add(pre_list.get(j));
                    }
                }
            }
            
            for(int j = 0; j < pre_list.size(); j++){
                for(int k = 0; k < in_list_right.size(); k++){
                    if(pre_list.get(j) == in_list_right.get(k)){
                        pre_list_right.add(pre_list.get(j));
                    }
                }
            }
            
            t.left = reC(pre_list_left, in_list_left);
            t.right = reC(pre_list_right, in_list_right);
            
            return t;
        }else{
            return null;
        }
    }
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        ArrayList<Integer> pre_list = new ArrayList<Integer>();
        ArrayList<Integer> in_list = new ArrayList<Integer>();
        
        for(int i = 0; i < pre.length; i++){
            pre_list.add(pre[i]);
        }
        
        for(int i = 0; i < in.length; i++){
            in_list.add(in[i]);
        }
        
        return reC(pre_list, in_list);
    }
    
    public static void main(String[] args) throws Exception{
    	int[] pre = {1,2,4,7,3,5,6,8};
    	int[] in = {4,7,2,1,5,3,8,6};
    	Father s = new Father();
    	TreeNode  t = s.reConstructBinaryTree(pre, in);
    	System.out.println("a");
    }
}

给出前序和中序遍历，重构树

利用递归的思想（输入为两个ArrayList,pre和in）整个方法就为根据两个ArrayList重构树

每一次所作的事情就是从前序中找出根节点，再将中序划分为两部分（根据根节点在中序中的位置）

只要再将前序分为两个部分（根据中序划分出来的两部分）

这样一共有四个ArrayList，可以用来左右的重构。

递归重构左子树

递归重构右子树