算法跟学Day14【代码随想录】

Svetlana丶

已于 2023-06-20 10:28:45 修改

阅读量45

点赞数

分类专栏：算法跟学文章标签：算法数据结构 leetcode java

于 2023-06-20 10:28:33 首次发布

本文链接：https://blog.csdn.net/qq_37016176/article/details/131301454

版权

算法跟学专栏收录该内容

32 篇文章 0 订阅

订阅专栏

第六章二叉树01

大纲

理论
遍历方式
- 前序
- 中序
- 后序
- 层序

理论

二叉树题目分类大纲
- 二叉树遍历方式
  - 144.前序遍历
  - 94.中序遍历
  - 145.后序遍历
  - 102.层序遍历
- 二叉树的属性
  - 101.对称二叉树
  - 104.二叉树最大深度
  - 111.二叉树最小深度
  - 222.完全二叉树节点个数
  - 110.平衡二叉树
  - 257.二叉树所有路径
  - 404.左叶子之和
  - 513.找树左下角之和
  - 112.路径总和
- 二叉树的修改与构造
  - 226.翻转二叉树
  - 106.从中序和后序遍历序列构造二叉树
  - 654.最大二叉树
  - 617.合并二叉树
- 二叉搜索树的属性
  - 700.二叉搜索树中的搜索
  - 98.验证二叉搜索树
  - 530.二叉搜索树的最小绝对差
  - 501.二叉搜索树中的众数
  - 538.把二叉搜索树转换为累加树
- 公共祖先问题
  - 236.二叉树最近公共祖先
  - 235.二叉搜索树最近公共祖先
- 二叉搜索树的修改和构造
  - 701.二叉搜索树种的插入操作
  - 450.删除二叉搜索树中的节点
  - 669.修剪二叉搜索树
  - 108.将有序数组转换为二叉搜索树
二叉树的种类
- 满二叉树
- 完全二叉树
- 二叉搜索树
- 平衡二叉搜索树 AVL

二叉树的存储方式

顺序存储
- 数组存储
- 关系：父节点下标为i 左孩子2i+1 有孩子2i+2

链式存储

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

遍历方式
- 深度优先遍历前中后序递归/迭代
- 广度优先遍历层序迭代

二叉树的遍历

`leetcode 144` 前序遍历

递归

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if (root == null) return res;
        res.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        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.pop();
            res.add(node.val);
            if (node.right != null) stack.push(node.right);
            if (node.left != null) stack.push(node.left);
        }
        return res;
    }
}

`leetcode 94` 中序遍历

递归

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

迭代

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

`leetcode 145` 后续遍历

递归

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

迭代

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

`leetcode 102` 层序遍历

递归

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        order(root, 0);
        return res;
    }

    public void order(TreeNode node, int deep) {
        if (node == null) return;
        if (res.size() < ++deep) res.add(new ArrayList<Integer>());
        res.get(deep - 1).add(node.val);
        order(node.left, deep);
        order(node.right, deep);
    }
}

迭代

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> item = new ArrayList<>();
            while (size-- > 0) {
                TreeNode node = queue.poll();
                item.add(node.val);
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
            res.add(item);
        }
        return res;
    }
}