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

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> levelOrder(TreeNode root){ //分层遍历

List> retList=new ArrayList<>();

if(root==null){

return retList;

}

Queue 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 preOrder(TreeNode root){ //线序遍历

if(root==null){

return new ArrayList<>();

}

List list=new ArrayList<>();

List leftPreOrder=preOrder(root.left);

List 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));

}

}

输出结果：

标签：node,遍历,TreeNode,level,二叉树,new,Java,null,root

来源： https://blog.csdn.net/Richchigga/article/details/100080501