关于二叉树的遍历：递归方式和非递归方式

利用递归方式遍历二叉树完整代码如下：

package treepack;

//个人理解：使用递归就是每个节点会经过三次，第一次是来到当前节点，第二次是遍历左边回来当前节点，第三次是遍历右边回到当前节点
//打印的时机，可以选择到达当前节点就打印再遍历左右，或者是遍历完左边节点打印当前节点再遍历右，或者是先遍历左右之后再打印当前节点。
//其实每次遍历左右的时候都有一次打印（把左右当成当前节点）。
public class Node {
	public int value;
	public Node left;
	public Node right;

	public Node(int value) {
		this.value = value;
	}

	public static void preOrderRecur(Node head) {
		if (head == null) {
			return;
		}
		System.out.print(head.value + " ");
		preOrderRecur(head.left);

		preOrderRecur(head.right);
	}

	public static void midOrderRecur(Node head) {
		if (head == null) {
			return;
		}
		midOrderRecur(head.left);
		System.out.print(head.value + " ");
		midOrderRecur(head.right);
	}

	public static void postOrderRecur(Node head) {
		if (head == null) {
			return;
		}
		postOrderRecur(head.left);
		postOrderRecur(head.right);
		System.out.print(head.value + " ");

	}

	public static void main(String[] args) {
		Node node = new Node(1);
		node.left = new Node(2);
		node.right = new Node(3);
		node.left.left = new Node(4);
		node.left.right = new Node(5);
		node.right.left = new Node(6);
		node.right.right = new Node(7);
		System.out.println("前序：");
		preOrderRecur(node);
		System.out.println();
		System.out.println("开始中序：");
		midOrderRecur(node);
		System.out.println();
		System.out.println("后序遍历开始");
		postOrderRecur(node);

	}
}

控制台打印如下：

 

 

 

非递归代码：

package treepack;

import java.util.Stack;

//自己申请栈来放节点。
class Node2 {
	int value;
	Node2 left;
	Node2 right;

	public Node2(int value) {
		this.value = value;
	}
}

public class TreeRecue {
	public static void preOrderUnrecur(Node2 head) {
		if (head != null) {
			// 首先是针对当前的head，如果不为空，马上从栈中取出一个，然后将当前head的左右孩子进行处理，一直处理完成，之后再处理另一边。
			Stack<Node2> stack = new Stack<Node2>();
			stack.add(head);
			while (!stack.isEmpty()) {
				head = stack.pop();
				System.out.print(head.value + " ");
				if (head.right != null) {
					stack.push(head.right);
				}
				if (head.left != null) {
					stack.push(head.left);
				}
			}
		}
	}

	public static void midOrderUnrecur(Node2 head) {
		Stack<Node2> stack = new Stack<Node2>();
		// 先把左边界全部放到栈容器中
		while (head != null || !stack.isEmpty()) {
			if (head != null) {
				stack.push(head);
				head = head.left;
			} else {
				// 连续取出两个左边界，然后取出右边一个
				head = stack.pop();
				System.out.print(head.value + " ");
				head = head.right;// 这个else里面都是孩子为null,
				// 这句话是跳转到当前节点（空节点）的孩子，这个孩子也肯定是空，所以会继续跳到这个else中来
			}

		}

	}

	public static void postOrderUnrecur(Node2 head) {
		// 使用两个栈来配合完成
		Stack<Node2> stack1 = new Stack<Node2>();
		Stack<Node2> stack2 = new Stack<Node2>();
		stack1.add(head);

		while (!stack1.isEmpty()) {
			head = stack1.pop();
			stack2.push(head);
			if (head.left != null) {
				stack1.push(head.left);

			}
			if (head.right != null) {
				stack1.push(head.right);
			}
		}

		while (!stack2.isEmpty()) {
			System.out.print(stack2.pop().value + " ");
		}
	}

	public static void main(String[] args) {
		Node2 node = new Node2(1);
		node.left = new Node2(2);
		node.right = new Node2(3);
		node.left.left = new Node2(4);
		node.left.right = new Node2(5);
		node.right.left = new Node2(6);
		node.right.right = new Node2(7);
		System.out.println("先序遍历：");
		TreeRecue.preOrderUnrecur(node);
		System.out.println();
		System.out.println("中序遍历：");

		TreeRecue.midOrderUnrecur(node);
		System.out.println();

		System.out.println("后序遍历：");
		TreeRecue.postOrderUnrecur(node);
	}
}

控制台：