基本性质

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

非空二叉树第\(n\)层最多有\(2^{n-1}\)个元素。

深度为\(h\)的二叉树，至多有\(2^h-1\)个结点。

结点结构

class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode(int x) { val = x; }

}

二叉树的遍历

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

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

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

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

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

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

前序遍历：abdefgc

中序遍历：debgfac

后序遍历：edgfbca

层次遍历：abcdfeg

前序遍历

递归实现

List preorderTraversal(TreeNode root) {

List result = new ArrayList();

if (root == null)

return result;

result.add(root.val);

result.addAll(preorderTraversal(root.left));

result.addAll(preorderTraversal(root.right));

return result;

}

非递归实现

List preorderTraversal(TreeNode root) {

List result = new ArrayList();

if (root == null)

return result;

Stack stack = new Stack();

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 preorderTraversal(TreeNode root) {

List result = new ArrayList();

if (root == null)

return result;

Stack stack = new Stack();

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 inorderTraversal(TreeNode root) {

List result = new ArrayList();

if (root == null)

return result;

result.addAll(inorderTraversal(root.left));

result.add(root.val);

result.addAll(inorderTraversal(root.right));

return result;

}

非递归实现

List inorderTraversal(TreeNode root) {

List result = new ArrayList();

if (root == null)

return result;

Stack stack = new Stack();

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 postorderTraversal(TreeNode root) {

List result = new ArrayList();

if (root == null)

return result;

result.addAll(postorderTraversal(root.left));

result.addAll(postorderTraversal(root.right));

result.add(root.val);

return result;

}

非递归实现

List postorderTraversal(TreeNode root) {

List result = new ArrayList();

if (root == null)

return result;

Stack stack = new Stack();

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 levelTraversal(TreeNode root) {

List result = new ArrayList();

if (root == null)

return result;

LinkedList queue = new LinkedList();

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;

}