[Java]对二叉树进行先序，中序，后序遍历以及分层遍历

最新推荐文章于 2022-12-29 16:29:33 发布

88_Rising

最新推荐文章于 2022-12-29 16:29:33 发布

阅读量151

点赞数 1

分类专栏： Java 文章标签： [Java]对二叉树进行先序，中序，后序遍历以及分层遍历

本文链接：https://blog.csdn.net/Richchigga/article/details/100080501

版权

Java 专栏收录该内容

54 篇文章 3 订阅

订阅专栏

import java.beans.IntrospectionException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode (int val,TreeNode left,TreeNode right)
    {
        this.val=val;
        this.left=left;
        this.right=right;
    }
}
class Element{
    TreeNode node;
    int level;
    Element (TreeNode node,int level){
        this.node=node;
        this.level=level;
    }
}
public class Solution {
    public static List<List<Integer>> levelOrder(TreeNode root){    //分层遍历
        List<List<Integer>> retList=new ArrayList<>();
        if(root==null){
            return retList;
        }
        Queue<Element> queue=new LinkedList<>();
        Element e=new Element(root,0);
        e.node=root;
        e.level=0;
        queue.add(e);
        while(!queue.isEmpty()){
        Element front=queue.poll();
            if(front.level==retList.size()){
                retList.add(new ArrayList<>());
            }
            retList.get(front.level).add(front.node .val);
            if(front.node.left!=null) {
            Element l = new Element(root,0);
            l.node = front.node.left;
            l.level = front.level + 1;
            queue.add(l);
        }
            if(front.node.right!=null) {
                Element d = new Element(root,0);
                d.node = front.node.right;
                d.level = front.level + 1;
                queue.add(d);
        }
    }
        return  retList;
}
public static void preOrderTraversal(TreeNode root){  //线序遍历
        if(root==null){
            return;
        }
        System.out.println(root.val);
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
}
public static boolean isEmpty(TreeNode root){   // 判断树是否为空
        return root==null;
}
public static  void inOrderTraversal(TreeNode root){ //中序遍历
        if(root==null){
            return ;
        }
        inOrderTraversal(root.left);
        System.out.println(root.val);
        inOrderTraversal(root.right);

}
public static void postOrderTraversal(TreeNode root){ //后续遍历
        if(root==null){
            return;
        }
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
        System.out.println(root.val);
}
public static List<Integer> preOrder(TreeNode root){ //先序遍历
        if(root==null){
            return new ArrayList<>();
        }
        List<Integer> list=new ArrayList<>();
        List<Integer> leftPreOrder=preOrder(root.left);
        List<Integer> rightPreOrder=preOrder(root.right);
        list.add(root.val);
        list.addAll(leftPreOrder);
        list.addAll(rightPreOrder);
        return list;
}
    public static void main(String[] args) {
        TreeNode node5=new TreeNode(5,null,null);
        TreeNode node4=new TreeNode(4,null,node5);
        TreeNode node3=new TreeNode(3,null,null);
        TreeNode node7=new TreeNode(7,null,null);
        TreeNode node6=new TreeNode(6,null,node7);
        TreeNode node2=new TreeNode(2,node3,node6);
        TreeNode node1=new TreeNode(1,node4,node2);
        System.out.println(isEmpty(node1));
        preOrderTraversal(node1);
        System.out.println("====================");
        inOrderTraversal(node1);
        System.out.println("====================");
        preOrderTraversal(node1);
        System.out.println("====================");
        System.out.println(preOrder(node1));
        System.out.println("====================");
        System.out.println(levelOrder(node1));
    }
}