通常树有四种遍历方法:1.层次遍历(需要用到树的高度,此文没有考虑)
其实递归和非递归的区别也就是非递归使用stack来回溯(也可以看做是一种特殊的递归)
2.前序遍历(根左右);3.中序遍历(左根右);4.后序遍历(左右根)
树的结构如下:
层次遍历:123456789
前序遍历:124895367
中序遍历:849251637
后序遍历:894526731
java代码实现三种遍历的递归和和非递归实现
package com.lip.datastructure.tree;
import java.util.Stack;
/**
* @author lip
*/
public class Tree
{
public static void main(String[] args)
{
Node<Integer>root=getNode();
System.out.println("前序遍历(非递归)");
preOrder(root);
System.out.println("前序遍历(递归)");
preOrderRecursive(root);
System.out.println();
System.out.println("中序遍历(非递归)");
infixOrder(root);
System.out.println("中序遍历(递归)");
infixOrderRecursive(root);
System.out.println();
System.out.println("后序遍历(非递归)");
postOrder(root);
System.out.println("后序遍历(递归)");
postOrderRecursive(root);
}
public static Node getNode()
{
Node<Integer>node1=new Node(1);
Node<Integer>node2=new Node(2);
Node<Integer>node3=new Node(3);
node1.left=node2;
node1.right=node3;
Node<Integer>node4=new Node(4);
Node<Integer>node5=new Node(5);
node2.left=node4;
node2.right=node5;
Node<Integer>node6=new Node(6);
Node<Integer>node7=new Node(7);
node3.left=node6;
node3.right=node7;
Node<Integer>node8=new Node(8);
Node<Integer>node9=new Node(9);
node4.left=node8;
node4.right=node9;
return node1;
}
//前序遍历,非递归
@SuppressWarnings("rawtypes")
public static void preOrder(Node root)
{
Stack<Node>stack=new Stack<Node>();
stack.push(root);
while(stack.size()>0)
{
Node tempNode=stack.pop();
if(tempNode!=null)
{
System.out.print(tempNode.data);
stack.push(tempNode.right);
stack.push(tempNode.left);
}
}
System.out.println();
}
//前序遍历(根左右),递归
public static void preOrderRecursive(Node root)
{
if(root!=null)
{
System.out.print(root.data);
preOrderRecursive(root.left);
preOrderRecursive(root.right);
}
}
//中序遍历(左根右),非递归
public static void infixOrder(Node root)
{
Stack<Node>stack=new Stack<Node>();
stack.push(root);
while(stack.size()>0)
{
Node temp=stack.pop();
if(temp!=null)
{
if((temp.left==null)&&(temp.right==null))
System.out.print(temp.data);
else
{
stack.push(temp.right);
stack.push(new Node(temp.data));
stack.push(temp.left);
}
}
}
System.out.println();
}
//中序遍历(左根右),递归
public static void infixOrderRecursive(Node root)
{
if(root!=null)
{
infixOrderRecursive(root.left);
System.out.print(root.data);
infixOrderRecursive(root.right);
}
}
//后序遍历(左右根),非递归
public static void postOrder(Node root)
{
Stack<Node>stack=new Stack<Node>();
stack.push(root);
Node temp;
while(stack.size()>0)
{
temp=stack.pop();
if(temp!=null)
{
if(temp.left==null&&temp.right==null)
System.out.print(temp.data);
else {
stack.push(new Node(temp.data));
stack.push(temp.right);
stack.push(temp.left);
}
}
}
System.out.println();
}
//后序遍历(左右根),递归
public static void postOrderRecursive(Node root)
{
if(root!=null)
{
postOrderRecursive(root.left);
postOrderRecursive(root.right);
System.out.print(root.data);
}
}
}
class Node <T>
{
public Node left;
public Node right;
public T data;
public Node(T data)
{
this.data=data;
}
}
其实递归和非递归的区别也就是非递归使用stack来回溯(也可以看做是一种特殊的递归)