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

基本性质

每个结点最多有两棵子树，左子树和右子树，顺序不可颠倒。非空二叉树第nn层最多有2n−12n−1个元素。深度为hh的二叉树，至多有2h−12h−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;
}