java版的二叉树的先序遍历、中序遍历以及后序遍历(递归以及非递归方式)

        二叉树的遍历有两种方式，一种是比较简单的递归方式，另一种是借助栈来实现的循环方式。

                                                                                                                                              

                                                                                                                                          二叉树结构：

        先介绍简单的递归方式：

package com.moluo.binarytree;
/**
 * @author 行者摩罗
 */
public class Node {
	private int data;
	private Node leftNode;
	private Node rightNode;
	public Node(int data, Node leftNode, Node rightNode){
		this.data = data;
		this.leftNode = leftNode;
		this.rightNode = rightNode;
	}

	public int getData() {
		return data;
	}
	public void setData(int data) {
		this.data = data;
	}
	public Node getLeftNode() {
		return leftNode;
	}
	public void setLeftNode(Node leftNode) {
		this.leftNode = leftNode;
	}
	public Node getRightNode() {
		return rightNode;
	}
	public void setRightNode(Node rightNode) {
		this.rightNode = rightNode;
	}
}

package com.moluo.binarytree;

import java.util.Stack;

public class BinaryTree {
	/**
	 * @author 行者摩罗
	 * 二叉树的先序中序后序排序
	 */
	public Node init() {//注意必须逆序建立，先建立子节点，再逆序往上建立，因为非叶子结点会使用到下面的节点，而初始化是按顺序初始化的，不逆序建立会报错
		Node J = new Node(8, null, null);
		Node H = new Node(4, null, null);
		Node G = new Node(2, null, null);
		Node F = new Node(7, null, J);
		Node E = new Node(5, H, null);
		Node D = new Node(1, null, G);
		Node C = new Node(9, F, null);
		Node B = new Node(3, D, E);
		Node A = new Node(6, B, C);
		return A;   //返回根节点
	}
	public void printNode(Node node){
		System.out.print(node.getData());
	}
	public void theFirstTraversal(Node root) {  //先序遍历
		printNode(root);
		if (root.getLeftNode() != null) {  //使用递归进行遍历左孩子
			theFirstTraversal(root.getLeftNode());
		}
		if (root.getRightNode() != null) {  //递归遍历右孩子
			theFirstTraversal(root.getRightNode());
		}
	}
	public void theInOrderTraversal(Node root) {  //中序遍历
		if (root.getLeftNode() != null) {
			theInOrderTraversal(root.getLeftNode());
		}
		printNode(root);
		if (root.getRightNode() != null) {
			theInOrderTraversal(root.getRightNode());
		}
	}
	public void thePostOrderTraversal(Node root) {  //后序遍历
		if (root.getLeftNode() != null) {
			thePostOrderTraversal(root.getLeftNode());
		}
		if(root.getRightNode() != null) {
			thePostOrderTraversal(root.getRightNode());
		}
		printNode(root);
	}
	
	public static void main(String[] args) {
		BinaryTree tree = new BinaryTree();
		Node root = tree.init();
		System.out.println("先序遍历");
		tree.theFirstTraversal(root);
		System.out.println("");
		System.out.println("中序遍历");
		tree.theInOrderTraversal(root);
		System.out.println("");
		System.out.println("后序遍历");
		tree.thePostOrderTraversal(root);
		System.out.println("");
	}
}

输出结果：

先序遍历
631254978
中序遍历
123456789
后序遍历
214538796

借助栈来实现的非递归方式：

         先序遍历和中序遍历都比较简单，就不解释了。简单解释一下后序遍历，上述二叉树的后序遍历结果是：214538796。将后序遍历结果逆序得到：697835412。即逆后序遍历结果为：697835412。通过观察逆后序遍历结果，可发现，逆后序遍历结果可以通过将前序遍历的遍历顺序的第二步和第三步互换一下即可。即：先遍历根节点，然后遍历右孩子，最后遍历左孩子。

//===============采用非递归方式========================
	public void theFirstTraversal_Stack(Node root) {  //先序遍历
		Stack<Node> stack = new Stack<Node>();
		Node node = root;
		while (node != null || stack.size() > 0) {  //将所有左孩子压栈
			if (node != null) {   //压栈之前先访问
				printNode(node);
				stack.push(node);
				node = node.getLeftNode();
			} else {
				node = stack.pop();
				node = node.getRightNode();
			}
		}
	}
	
	public void theInOrderTraversal_Stack(Node root) {  //中序遍历
		Stack<Node> stack = new Stack<Node>();
		Node node = root;
		while (node != null || stack.size() > 0) {
			if (node != null) {
				stack.push(node);   //直接压栈
				node = node.getLeftNode();
			} else {
				node = stack.pop(); //出栈并访问
				printNode(node);
				node = node.getRightNode();
			}
		}
	}
	
	public void thePostOrderTraversal_Stack(Node root) {   //后序遍历
		Stack<Node> stack = new Stack<Node>();
		Stack<Node> output = new Stack<Node>();//构造一个中间栈来存储逆后序遍历的结果
		Node node = root;
		while (node != null || stack.size() > 0) {
			if (node != null) {
				output.push(node);
				stack.push(node);				
				node = node.getRightNode();
			} else {
				node = stack.pop();				
				node = node.getLeftNode();
				
			}
		}
		while (output.size() > 0) {
			printNode(output.pop());
		}
	}

输出结果：

=====非递归方式========
先序遍历
631254978
中序遍历
123456789
后序遍历
214538796

尊重版权，转载请注明本文链接

                                      

                                           欢迎关注行者摩罗微信公众号(xingzhemoluo)，共同交流编程经验，扫描下方二维码即可;