题目列表
理论基础
二叉树的种类
满二叉树
如果一棵二叉树只有度为0和度为2的节点，并且度为0的节点在同一层上，则这棵二叉树为满二叉树。
满二叉树的深度为k，有2^k-1个节点的二叉树。
完全二叉树
在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。
优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系。
二叉搜索树
二叉搜索树是一个有序树。
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉排序树。
平衡二叉搜索树
平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn，而unordered_map、unordered_set，unordered_map、unordered_set底层实现是哈希表。
二叉树的存储方式
二叉树可以链式存储，也可以顺序存储。
链式存储方式用指针， 顺序存储的方式就是用数组。
顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在各个地址的节点串联一起。
链式存储如图：
顺序存储如图：
如果父节点的数组下标是i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。
二叉树的遍历方式
二叉树主要有两种遍历方式：
- 深度优先搜索：先往深走，遇到叶子节点再往回走；
- 广度优先遍历：一层一层地去遍历。
深度优先遍历：
- 前序遍历（递归法、迭代法、一致迭代法）
- 中左右
- 中序遍历（递归法、迭代法、一致迭代法）
- 左中右
- 后序遍历（递归法、迭代法、一致迭代法）
- 左右中
广度优先遍历
- 层序遍历（迭代法）
深度优先遍历一般用递归来实现，广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层地来遍历二叉树。
二叉树的定义
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
解题过程
递归遍历
递归算法三要素：
- 确定递归函数的参数和返回值
- 确定终止条件
- 确定单层递归的逻辑
前序遍历
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
traversal(root, res);
return res;
}
public void traversal(TreeNode node, List<Integer> myList) {
if (node == null) {
return;
}
myList.add(node.val);
traversal(node.left, myList);
traversal(node.right, myList);
}
}
中序遍历
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
traversal(root, res);
return res;
}
public void traversal(TreeNode node, List<Integer> myList) {
if (node == null) {
return;
}
traversal(node.left, myList);
myList.add(node.val);
traversal(node.right, myList);
}
}
后序遍历
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
traversal(root, res);
return res;
}
public void traversal(TreeNode node, List<Integer> myList) {
if (node == null) {
return;
}
traversal(node.left, myList);
traversal(node.right, myList);
myList.add(node.val);
}
}
迭代遍历
前序遍历： 前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。这样出栈的时候就是中左右的顺序。
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
//边界条件
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
res.add(node.val);
if (node.right != null) {
stack.push(node.right);
}
if (node.left != null) {
stack.push(node.left);
}
}
return res;
}
}
中序遍历
- 处理：将元素放进result数组中
- 访问：遍历节点
在使用迭代法写中序遍历，需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while (cur != null || !stack.isEmpty()) {
if (cur != null) {
stack.push(cur);
cur = cur.left; //一直到最左的节点
} else {
cur = stack.pop();
res.add(cur.val);
cur = cur.right;
}
}
return res;
}
}
后序遍历： 先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了，如下图：
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
res.add(node.val);
if (node.left != null) {
stack.push(node.left);
}
if (node.right != null) {
stack.push(node.right);
}
}
Collections.reverse(res); //反转列表
return res;
}
}
统一迭代
这里介绍一种统一风格的代码实现三种遍历方式。
我们发现，使用栈，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。
我们可以将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。
如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。
前序遍历
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
//边界条件
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.peek();
if (node != null) {
stack.pop();
if (node.right != null) { //空节点不入栈
stack.push(node.right);
}
if (node.left != null) { //空节点不入栈
stack.push(node.left);
}
stack.push(node); //添加中间节点
stack.push(null); //中间节点访问过，但是还没有处理，加入空节点作为标记
} else {
stack.pop(); //空节点弹出
node = stack.peek(); //重新取出栈中元素
stack.pop();
res.add(node.val); //加入到结果集
}
}
return res;
}
}
中序遍历
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new LinkedList<>();
Stack<TreeNode> st = new Stack<>();
if (root != null) st.push(root);
while (!st.empty()) {
TreeNode node = st.peek();
if (node != null) {
st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
if (node.right != null) {
st.push(node.right); // 添加右节点（空节点不入栈）
}
st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
if (node.left != null) {
st.push(node.left); // 添加左节点（空节点不入栈）
}
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
node = st.peek(); // 重新取出栈中元素
st.pop();
result.add(node.val); // 加入到结果集
}
}
return result;
}
}
后序遍历
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result = new LinkedList<>();
Stack<TreeNode> st = new Stack<>();
if (root != null) st.push(root);
while (!st.empty()) {
TreeNode node = st.peek();
if (node != null) {
st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
if (node.right != null) {
st.push(node.right); // 添加右节点（空节点不入栈）
}
if (node.left != null) {
st.push(node.left); // 添加左节点（空节点不入栈）
}
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
node = st.peek(); // 重新取出栈中元素
st.pop();
result.add(node.val); // 加入到结果集
}
}
return result;
}
}
总结
二叉树的前序、中序和后序遍历方式有递归、迭代、统一迭代三种实现方式，中序遍历的迭代和其他两种有所不同。
