代码随想录算法训练营 Day 14 | 二叉树理论基础，递归遍历，迭代遍历

理论基础

二叉树的种类

满二叉树

满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

如图所示：

​​

这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。

完全二叉树

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。

大家要自己看完全二叉树的定义，很多同学对完全二叉树其实不是真正的懂了。

我来举一个典型的例子如题：

​​

之前我们刚刚讲过优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系。

二叉搜索树

前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉排序树

下面这两棵树都是搜索树

​​

平衡二叉搜索树

平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

如图：

​​

最后一棵 不是平衡二叉树，因为它的左右两个子树的高度差的绝对值超过了1。

二叉树的存储方式

二叉树可以链式存储，也可以顺序存储。

二叉树的遍历方式

二叉树主要有两种遍历方式：

1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
2. 广度优先遍历：一层一层的去遍历。

那么从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式：

• 深度优先遍历

  • 前序遍历（递归法，迭代法）
  • 中序遍历（递归法，迭代法）
  • 后序遍历（递归法，迭代法）

• 广度优先遍历

  • 层次遍历（迭代法）

这里前中后，其实指的就是中间节点的遍历顺序，只要大家记住 前中后序指的就是中间节点的位置就可以了。

看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式

• 前序遍历：中左右
• 中序遍历：左中右
• 后序遍历：左右中

大家可以对着如下图，看看自己理解的前后中序有没有问题。

​​

递归遍历

144.二叉树的前序遍历

题目链接：144.二叉树的前序遍历

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<Integer>();
    preorder(root, result);
    return result;
}
public void preorder(TreeNode root, List<Integer> result) {
    if (root == null) {
        return;
    }
    result.add(root.val);
    preorder(root.left, result);
    preorder(root.right, result);
}

94.二叉树的中序遍历

题目链接：94.二叉树的中序遍历

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    inorder(root, res);
    return res;
}
void inorder(TreeNode root, List<Integer> list) {
    if (root == null) {
        return;
    }
    inorder(root.left, list);
    list.add(root.val);             // 注意这一句
    inorder(root.right, list);
}

145.二叉树的后序遍历

题目链接：145.二叉树的后序遍历

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    postorder(root, res);
    return res;
}
void postorder(TreeNode root, List<Integer> list) {
    if (root == null) {
        return;
    }
    postorder(root.left, list);
    postorder(root.right, list);
    list.add(root.val);             // 注意这一句
}

迭代遍历

前序遍历

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode cur = stack.pop();
        if (cur == null) {
            continue;
        }
        result.add(cur.val);
        // 注意:因为是栈结构,所以先添加在右节点,后添加左节点,才能让左节点先弹出
        stack.push(cur.right);
        stack.push(cur.left);
    }

    return result;
}

后序遍历

理解前序遍历迭代法后，可以这样子理解。前序是：中左右；后序是：左右中。我们可以首先调换前序代码中添加到栈中的左右顺序，这样结果集合中的值的顺序是 中右左，最后再把集合给翻转一下，就变成了左右中！

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode cur = stack.pop();
        if (cur == null) {
            continue;
        }
        result.add(cur.val);
        // 注意:这里调换顺序，先加入左节点，再加入右节点
        stack.push(cur.left);
        stack.push(cur.right);
    }
    // 翻转结果
    Collections.reverse(result);
    return result;
}

中序遍历

定义一个指针，用来寻找最左节点，每次都添加到栈中。当指针为空时就说明找到了，此时弹出最后进入的节点，添加到结果集中，然后让指针指向改节点的右子节点，然后寻找右子节点下面有没有左子节点。重复上述步骤。

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

​​

 

例如这张图，每次循环的栈和集合是，不知道能不能理解：

[5]		>>>>		[]
[5, 4]		>>>>		[]
[5, 4, 1]	>>>>		[]
[5, 4]		>>>>		[1]
[5]		>>>>		[1, 4]
[5, 2]		>>>>		[1, 4]
[5]		>>>>		[1, 4, 2]
[]		>>>>		[1, 4, 2, 5]
[6]		>>>>		[1, 4, 2, 5]
[6, 7]		>>>>		[1, 4, 2, 5]
[6]		>>>>		[1, 4, 2, 5, 7]
[]		>>>>		[1, 4, 2, 5, 7, 6]
[8]		>>>>		[1, 4, 2, 5, 7, 6]
[]		>>>>		[1, 4, 2, 5, 7, 6, 8]

统一迭代法

不太理解，周末复习一下。

总结

第一次理解二叉树的遍历。。