java 树 先序遍历_树的遍历--先序/中序/后序--递归/非递归--java

import java.lang.reflect.AnnotatedElement;

import java.util.ArrayList;

import java.util.List;

import javax.swing.border.EmptyBorder;

public class main8 {

public static class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode(int x) { val = x; }

}

//递归方式

//先序遍历

public static void preordertravel(TreeNode node)

{

if(node==null)

return;

System.out.print(node.val+" ");

preordertravel(node.left);

preordertravel(node.right);

}

//中序遍历

public static void middletravel(TreeNode node)

{

if(node==null)

return;

middletravel(node.left);

System.out.print(node.val+" ");

middletravel(node.right);

}

//后序遍历

public static void behindtravel(TreeNode node)

{

if(node==null)

return;

behindtravel(node.left);

behindtravel(node.right);

System.out.print(node.val+" ");

}

//非递归方式

//先序遍历

//规则：(1)先把头结点放入栈

//(2)对于新放入栈的节点，出栈并输出，并依次放入右节点，左节点

//(3)重复(2)操作，直至栈为空

public static void preordersort2(TreeNode node)

{

List nodes=new ArrayList();

nodes.add(node);

while(nodes.size()!=0)

{

TreeNode treeNode=nodes.get(nodes.size()-1);

System.out.print(treeNode.val+" ");

nodes.remove(nodes.size()-1);

if(treeNode.right!=null)

{

nodes.add(treeNode.right);

}

if(treeNode.left!=null)

{

nodes.add(treeNode.left);

}

}

System.out.println();

}

//中序遍历

// 规则：

//(1) 把头结点放入

//(2)对于每一个新放入的节点都把它的左节点放入

//(3)当没有左节点要放入时，就出栈并输出栈顶的节点 并把它的右节点放入 然后对于该节点执行(2)

public static void middlesort2(TreeNode node)

{

List nodes=new ArrayList();

nodes.add(node);

int n=0;

while(nodes.size()!=0)

{

TreeNode treeNode=nodes.get(nodes.size()-1);

if(treeNode.left!=null&&n==0)

{

nodes.add(treeNode.left);

}

else {

System.out.print(treeNode.val+" ");

nodes.remove(nodes.size()-1);

n=1;//注意必须有新右节点放入时才能 继续 放栈顶的左节点

if(treeNode.right!=null)

{

nodes.add(treeNode.right);

n=0;

}

}

}

System.out.println();

}

// 后序遍历

//规则：

//(1)把头结点放入栈 1

//(2)对于新放入的节点，出栈并放入栈2，在栈1中分别按顺序放入它的左节点和右节点

//(3)重复步骤2，直至栈1为空

// (4)输出栈2的元素

public static void behindordersort2(TreeNode node)

{

List nodes1=new ArrayList();

List nodes2=new ArrayList();

nodes1.add(node);

while(nodes1.size()!=0)

{

TreeNode treeNode=nodes1.get(nodes1.size()-1);

nodes2.add(treeNode);

nodes1.remove(nodes1.size()-1);

if(treeNode.left!=null)

{

nodes1.add(treeNode.left);

}

if(treeNode.right!=null)

{

nodes2.add(treeNode.right);

}

}

while(nodes2.size()!=0)

{

System.out.print(nodes2.get(nodes2.size()-1).val+" ");

nodes2.remove(nodes2.size()-1);

}

System.out.println();

}

// 非递归方式

//层次遍历

//(1)向队列中放入头节点

//(2)出队一个元素，并将它的左节点和右节点进队

//(3)重复(2)操作，直至队列为空

public static void leveltravel(TreeNode node)

{

List nodes=new ArrayList();

nodes.add(node);

while(nodes.size()!=0)

{

TreeNode treeNode=nodes.get(0);

System.out.print(treeNode.val+" ");

nodes.remove(0);

if(treeNode.left!=null)

nodes.add(treeNode.left);

if(treeNode.right!=null)

nodes.add(treeNode.right);

}

System.out.println();

}

public static void main(String[] args) {

// TODO Auto-generated method stub

TreeNode aNode=new TreeNode(1);

TreeNode bNode=new TreeNode(2);

TreeNode cNode=new TreeNode(3);

TreeNode dNode=new TreeNode(4);

TreeNode eNode=new TreeNode(5);

aNode.left=bNode;

aNode.right=cNode;

bNode.left=dNode;

bNode.right=eNode;

System.out.println("递归方式：");

System.out.println("先序遍历：");

preordertravel(aNode);

System.out.println();

System.out.println("中序遍历：");

middletravel(aNode);

System.out.println();

System.out.println("后序遍历：");

behindtravel(aNode);

System.out.println();

System.out.println("非递归方式：");

System.out.println("先序遍历：");

preordersort2(aNode);

System.out.println("中序遍历：");

middlesort2(aNode);

System.out.println("后序遍历：");

behindordersort2(aNode);

System.out.println("层次遍历");

leveltravel(aNode);

}

}