Day 12 - 树的基本内容 | 树的遍历 | Leetcode 144 & 145 & 94

imlxinyu

已于 2023-06-26 18:34:55 修改

阅读量71

点赞数

分类专栏： Leetcode 文章标签： leetcode 数据结构 java

于 2023-06-26 18:33:32 首次发布

本文链接：https://blog.csdn.net/imlxinyu/article/details/131386839

版权

Leetcode 专栏收录该内容

39 篇文章 0 订阅

订阅专栏

本文介绍了树的概念，包括满二叉树和完全二叉树，以及二叉树的遍历方法如深度优先和广度优先。重点讨论了二叉查找树的特性，插入和删除操作的时间复杂度。接着讲解了AVL树，一种保持平衡的二叉查找树，其左右子树高度差不超过1。最后展示了递归和非递归遍历二叉树的代码实现。

摘要由CSDN通过智能技术生成

树 Tree概念复习

满二叉树
完全二叉树——除了最下面一层之外，其他都是满的

二叉树遍历：

深度优先
- 前序遍历
- 中序遍历
- 后序遍历
广度优先
- 层次遍历

代码定义：

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;
    }
}

二叉查找树/二叉排序树

定义：对于每一个节点X，其左子树中all element值均小于X，右子树则大于X

中序遍历：递增
平均深度 $O (l o g N)$
二叉查找树的插入、删除

平衡二叉树 AVL树

带有平衡条件的二叉查找树，深度必须为 $O (l o g N)$
AVL树的左子树和右子树高度最多差1

AVL树插入！——需要对原树结构进行旋转(rotation)
4种情况：

递归遍历

leetcode 144 前序遍历 preorder traversal
leetcode 145 后序遍历 postorder traversal
leetcode 94 中序遍历 inorder traversal

前序遍历

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

后序遍历

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root, res);
        return res;
    }
    public void postorder(TreeNode root, List<Integer> res) {
        if (root == null)
            return;
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);
    }
}

中序遍历

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
    }
    public void inorder(TreeNode root, List<Integer> res) {
        if (root == null)
            return;
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }
}

非递归法遍历

用栈实现

代码实现：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new ArrayDeque<>();

        if (root == null)
            return res;
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode t = stack.pop();
            res.add(t.val);
            if (t.right != null)
                stack.push(t.right);    //先进后出
            if (t.left != null)
                stack.push(t.left);
        }
        return res;
    }
}

统一的非递归法（以中序遍历为例）：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();

        if (root != null)
            stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode temp = stack.peek();
            if (temp != null) {
                stack.pop();
                if (temp.right != null)
                    stack.push(temp.right);
                stack.push(temp);
                stack.push(null);
                if (temp.left != null)
                    stack.push(temp.left);
            }
            else {
                stack.pop();
                temp = stack.pop();
                res.add(temp.val);
            }
        }
        return res;
    }
}