重建二叉树（剑指offer第7题）以及树的四种遍历

最新推荐文章于 2019-05-17 16:56:31 发布

原创最新推荐文章于 2019-05-17 16:56:31 发布 · 182 阅读

0 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

58 篇文章

订阅专栏

本文介绍如何根据前序和中序遍历结果重建二叉树，并提供四种遍历方式（前序、中序、后序及层序）的具体实现。通过Java代码示例，展示了如何从给定序列中重构二叉树并进行遍历。

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

重建二叉树以及四种遍历

重建二叉树（剑指offer第7题）

根据前序+中序或者后序+中序遍历可以唯一确定一棵二叉树。

三种遍历方式（以根分类）

前序遍历：先访问根节点，再访问左子节点，最后访问右子节点。
中序遍历：先访问左子节点，再访问根节点，最后访问右子节点。
后续遍历：先访问左子节点，再访问右子节点，最后访问根节点。

层序遍历

一层一层的遍历，使用的是Queue,可以得到树的最大宽度。

代码实现

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
    public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if(pre.length == 0 || pre.length != in.length){
            return null;
        }
        TreeNode root = new TreeNode(pre[0]);
        for(int i = 0; i < pre.length; i++){
            if(pre[0] == in[i]){
                root.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, 1 + i),Arrays.copyOfRange(in, 0, i));
                root.right = reConstructBinaryTree(Arrays.copyOfRange(pre, 1 + i, pre.length), Arrays.copyOfRange(in, 1 + i, pre.length));
                break;
            }
        }
        return root;
    }

    static List<Integer> list = new ArrayList<Integer>();//中序遍历
    public static List<Integer> inOrderTraversal(TreeNode root){
        if(root != null){
            if(root.left != null){
                inOrderTraversal(root.left);
            }
            list.add(root.val);
            if(root.right != null){
                inOrderTraversal(root.right);
            }
        }
        return list;
    }

    static List<Integer> list2 = new ArrayList<Integer>();//前序遍历
    public static List<Integer> preOrderTraversal(TreeNode root){
        list2.add(root.val);
        if(root.left != null){
            preOrderTraversal(root.left);
        }
        if(root.right != null){
            preOrderTraversal(root.right);
        }
        return list2;
    }

    static List<Integer> list3 = new ArrayList<Integer>();//后序遍历
    public static List<Integer> postTraversal(TreeNode root){
        if(root.left != null){
            postTraversal(root.left);
        }
        if(root.right != null){
            postTraversal(root.right);
        }
        list3.add(root.val);
        return list3;
    }
    public static void main(String[] args) {
        int[] pre = {1,2,4,7,3,5,6,8};
        int[] in = {4,7,2,1,5,3,8,6};
        TreeNode root = reConstructBinaryTree(pre,in);
        System.out.println(root);
        System.out.println("in=" + inOrderTraversal(root));
        System.out.println("pre=" + preOrderTraversal(root));
        System.out.println("post=" + postTraversal(root));
    }
}

    static List<Integer> list4  = new ArrayList<Integer>();//层序遍历
    public static List<Integer> levelOrder(TreeNode root){
        int count = 0;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        count = 1;
        int a = 0;
        while (queue.size() > 0){
            TreeNode tn = queue.poll();
            count--;
            list4.add(tn.val);
            if(tn.left != null){
                queue.add(tn.left);
            }
            if( tn.right != null){
                queue.add(tn.right);
            }
            if(count == 0){
                count = queue.size();
            }
            if(a < count){
                a = count;
            }
        }
        System.out.println(a);
        return list4;
    }