1、定义一个节点类:
public class Node {
private int data;
private Node left;
private Node right;
public Node(){}
public Node(int data) {
this.data = data;
}
public Node(int data, Node left, Node right) {
super();
this.data = data;
this.left = left;
this.right = right;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node right) {
this.right = right;
}
}
2、算法实现类:
public class BinaryNode{
//前序遍历递归的方式
public void preOrder(Node root){
if(null!=root){
System.out.print(root.getData()+"\t");
preOrder(root.getLeft());
preOrder(root.getRight());
}
}
//前序遍历非递归的方式
public void preOrderNonRecursive(Node root){
Stack<Node> stack=new Stack<Node>();
while(true){
while(root!=null){
System.out.print(root.getData()+"\t");
stack.push(root);
root=root.getLeft();
}
if(stack.isEmpty()) break;
root=stack.pop();
root=root.getRight();
}
}
//中序遍历采用递归的方式
public void inOrder(Node root){
if(null!=root){
inOrder(root.getLeft());
System.out.print(root.getData()+"\t");
inOrder(root.getRight());
}
}
//中序遍历采用非递归的方式
public void inOrderNonRecursive(Node root){
Stack<Node> stack=new Stack<Node>();
while(true){
while(root!=null){
stack.push(root);
root=root.getLeft();
}
if(stack.isEmpty())break;
root=stack.pop();
System.out.print(root.getData()+"\t");
root=root.getRight();
}
}
//后序遍历采用递归的方式
public void postOrder(Node root){
if(root!=null){
postOrder(root.getLeft());
postOrder(root.getRight());
System.out.print(root.getData()+"\t");
}
}
//后序遍历采用非递归的方式
public void postOrderNonRecursive(Node root){
Stack<Node> stack=new Stack<Node>();
while(true){
if(root!=null){
stack.push(root);
root=root.getLeft();
}else{
if(stack.isEmpty()) return;
if(null==stack.lastElement().getRight()){
root=stack.pop();
System.out.print(root.getData()+"\t");
while(root==stack.lastElement().getRight()){
System.out.print(stack.lastElement().getData()+"\t");
root=stack.pop();
if(stack.isEmpty()){
break;
}
}
}
if(!stack.isEmpty())
root=stack.lastElement().getRight();
else
root=null;
}
}
}
//层序遍历
public void levelOrder(Node root){
Node temp;
Queue<Node> queue=new LinkedList<Node>();
queue.offer(root);
while(!queue.isEmpty()){
temp=queue.poll();
System.out.print(temp.getData()+"\t");
if(null!=temp.getLeft())
queue.offer(temp.getLeft());
if(null!=temp.getRight()){
queue.offer(temp.getRight());
}
}
}
}
3、遍历测试下图二叉树
public static void main(String[] args) {
Node node10=new Node(10,null,null);
Node node8=new Node(8,null,null);
Node node9=new Node(9,null,node10);
Node node4=new Node(4,null,null);
Node node5=new Node(5,node8,node9);
Node node6=new Node(6,null,null);
Node node7=new Node(7,null,null);
Node node2=new Node(2,node4,node5);
Node node3=new Node(3,node6,node7);
Node node1=new Node(1,node2,node3);
BinaryNode tree=new BinaryNode();
//采用递归的方式进行遍历
System.out.println("-----前序遍历------");
tree.preOrder(node1); // 1 2 4 5 8 9 10 3 6 7
System.out.println();
//采用非递归的方式遍历
tree.preOrderNonRecursive(node1); // 1 2 4 5 8 9 10 3 6 7
System.out.println();
//采用递归的方式进行遍历
System.out.println("-----中序遍历------");
tree.inOrder(node1); // 4 2 8 5 9 10 1 6 3 7
System.out.println();
//采用非递归的方式遍历
tree.inOrderNonRecursive(node1); // 4 2 8 5 9 10 1 6 3 7
System.out.println();
//采用递归的方式进行遍历
System.out.println("-----后序遍历------");
tree.postOrder(node1); // 4 8 10 9 5 2 6 7 3 1
System.out.println();
//采用非递归的方式遍历
tree.postOrderNonRecursive(node1); // 4 8 10 9 5 2 6 7 3 1
System.out.println();
//采用递归的方式进行遍历
System.out.println("-----层序遍历------");
tree.levelOrder(node1); // 1 2 3 4 5 6 7 8 9 10
System.out.println();
}