二叉树的遍历（前序、中序、后序、层次）

基本性质

每个结点最多有两棵子树，左子树和右子树，顺序不可颠倒。

  1. 非空二叉树第\(n\)层最多有\(2^{n-1}\)个元素。
  2. 深度为\(h\)的二叉树，至多有\(2^h-1\)个结点。

结点结构

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

二叉树的遍历

遍历即将树的所有结点都访问且仅访问一次。按照根结点访问次序的不同，可以分为前序遍历，中序遍历，后序遍历。

  • 前序遍历：根结点 -> 左子树 -> 右子树
  • 中序遍历：左子树 -> 根结点 -> 右子树
  • 后序遍历：左子树 -> 右子树 -> 根结点

另外还有一种层次遍历，即每一层都从左向右遍历。

例如：求下图的二叉树的遍历

前序遍历：abdefgc
中序遍历：debgfac
后序遍历：edgfbca
层次遍历：abcdfeg

前序遍历

递归实现
List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<Integer>();
    if (root == null)
        return result;
    result.add(root.val);
    result.addAll(preorderTraversal(root.left));
    result.addAll(preorderTraversal(root.right));
    return result;
}
非递归实现
List<integer> preorderTraversal(TreeNode root) {
    List<integer> result = new ArrayList<integer>();
    if (root == null)
        return result;
    Stack<treenode> stack = new Stack<treenode>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        result.add(node.val);
        if (node.right != null)
            stack.push(node.right);
        if (node.left != null)
            stack.push(node.left);
    }
    return result;

另一种实现方法：

List<Integer> preorderTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<Integer>();
	if (root == null)
		return result;
	Stack<TreeNode> stack = new Stack<TreeNode>();
	TreeNode p = root;
	while (p != null || !stack.isEmpty()) {
		if (p != null) {
			result.add(p.val);
			stack.push(p);
			p = p.left;
		} else {
			p = stack.pop();
			p = p.right;
		}
	}
	return result;
}

中序遍历

递归实现
List<Integer> inorderTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<Integer>();
	if (root == null)
		return result;
	result.addAll(inorderTraversal(root.left));
	result.add(root.val);
	result.addAll(inorderTraversal(root.right));
	return result;
}
非递归实现
List<Integer> inorderTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<Integer>();
	if (root == null)
		return result;
	Stack<TreeNode> stack = new Stack<TreeNode>();
	TreeNode p = root;
	while (p != null || !stack.isEmpty()) {
		if (p != null) {
			stack.push(p);
			p = p.left;
		} else {
			p = stack.pop();
			result.add(p.val);
			p = p.right;
		}
	}
	return result;
}

后序遍历

递归实现
List<Integer> postorderTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<Integer>();
	if (root == null)
		return result;
	result.addAll(postorderTraversal(root.left));
	result.addAll(postorderTraversal(root.right));
	result.add(root.val);
	return result;
}
非递归实现
List<Integer> postorderTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<Integer>();
	if (root == null)
		return result;
	Stack<TreeNode> stack = new Stack<TreeNode>();
	TreeNode p = root;
	TreeNode last = null;
	while (p != null || !stack.isEmpty()) {
		if (p != null) {
			stack.push(p);
			p = p.left;
		} else {
			TreeNode peek = stack.peek();
			if (peek.right != null && last != peek.right) {
				p = peek.right;
			} else {
				peek = stack.pop();
				result.add(peek.val);
				last = peek;
			}
		}
	}
	return result;
}

层次遍历

List<Integer> levelTraversal(TreeNode root) {
	List<Integer> result = new ArrayList<Integer>();
	if (root == null)
		return result;
	LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
	queue.addLast(root);
	while (queue.size() != 0) {
		TreeNode node = queue.pollFirst();
		result.add(node.val);
		if (node.left != null)
			queue.addLast(node.left);
		if (node.right != null)
			queue.addLast(node.right);
	}
	return result;
}