0
点赞
收藏
分享

微信扫一扫

[力扣]二叉树1—基础+遍历

夕颜合欢落 2022-04-29 阅读 65
leetcodeb树数据结构

代码随想录[原文指路]

概述

1.种类

  • 满二叉树：二叉树只有度(子节点个数)为0与2的节点，且度为0的节点在同一层
    在这里插入图片描述
  • 完全二叉树：底层以上全被填满，底层节点从左向右连续(集中于左边)
    在这里插入图片描述
  • 二叉搜索树(二叉排序树)
    在这里插入图片描述
满二叉树与完全二叉树没有数值的概念，而二叉搜索树有
1.若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值
2.若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值
3.它的左、右子树也分别为二叉排序树
  • 平衡二叉搜索树(AVL)：空树或左右两子树高度差绝对值不超过1，并且是平衡二叉树
    在这里插入图片描述

2.存储方式

  • 链式存储(链表)
    在这里插入图片描述
  • 顺序存储(数组)
    在这里插入图片描述

3.遍历方式

  • 深度优先(先往深处再往回)
1.前序遍历：中左右
2.中序遍历：左中右
3.后序遍历：左右中
  • 广度优先(层层向下)
层次遍历(迭代，队列)

深度优先遍历

1.递归三步走

  • 确定递归函数参数和返回值
确定哪些参数是递归的过程中需要处理的进而确定递归函数的参数
确定每次递归的返回值是什么进而确定递归函数的返回类型
  • 确定终止条件
  • 确定单层递归逻辑
确定每层递归需要处理的信息，清晰重复调用自己实现递归的过程

2.二叉树的前序遍历[144]

class Solution {
    public List<Integer> preorderTraversal(TreeNode root){
        List<Integer> 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> preorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> st = new Stack<>();
        if(root!=null)st.push(root);
        //注意空节点不入栈
        while(!st.isEmpty()){
            TreeNode node = st.peek();
            if(node!=null){
                st.pop();//将当前节点弹出避免重复操作
                if(node.right!=null) st.push(node.right);//添加右节点
                if(node.left!=null) st.push(node.left);//添加左节点
                st.push(node);//添加中间节点
                st.push(null);//中节点访问过，但是还没有处理，加入空节点做为标记
            } else {//遇到空节点时将下一个节点放进结果集
                st.pop();//将空节点弹出
                node = st.peek();//取出空节点的下一个节点
                st.pop();//出栈
                result.add(node.val);//加入结果集
            }
        }
        return result;
    }
}
  • 迭代
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                list.add(root.val);
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            root = root.right;
        }
        return list;
    }
}

3.二叉树的中序遍历[94]

  • 递归
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        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> 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> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            list.add(root.val);
            root = root.right;
        }
        return list;
    }
}

4.二叉树的后序遍历[145]

class Solution {
    public List<Integer> postorderTraversal(TreeNode root){
        List<Integer> res = new ArrayList<Integer>();
        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> 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;
    }
}

广度优先遍历

  • 每个题都是1基础上改进

1.二叉树的层序遍历[102]

  • 迭代
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ress = new ArrayList();
        List<Integer> res;
        if(root==null) return ress;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            res = new ArrayList();
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                res.add(node.val);
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            ress.add(res);
        }
        return ress;
    }
}

2.二叉树的层序遍历 II[107]

  • 在前一题基础上反转结果，此处借助堆，便于反转
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> ress = new ArrayList();
        Stack<List<Integer>> stack = new Stack();
        List<Integer> res;
        if(root==null) return ress;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            res = new ArrayList();
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                res.add(node.val);
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            stack.push(res);
        }
       
        while(!stack.isEmpty()) ress.add(stack.pop());
        return ress;
    }
}

3.二叉树的右视图[199]

  • 取每层最后节点保存
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        //并不是简单的输出所有右子树的右子树...
        //层序遍历，每一层取最后节点保存
        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();
            TreeNode node = null;
            for(int i=0;i<size;i++){
                node = queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            res.add(node.val);
        }
        return res;
    }
}

4.二叉树的层平均值[637]

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ress = new ArrayList();
        if(root==null) return ress;

        double res;
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            res = 0.0;
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                res += node.val;
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            ress.add(res/size);
        }
        return ress;
    }
}

5.N 叉树的层序遍历[429]

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> ress = new ArrayList();
        List<Integer> res;
        if(root==null) return ress;

        Queue<Node> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            res = new ArrayList();
            int size = queue.size();
            for(int i=0;i<size;i++){
                Node node = queue.poll();
                res.add(node.val);
                if(node.children!=null){
                    for(Node no:node.children){
                        queue.offer(no);
                    }
                }
            }
            ress.add(res);
        }
        return ress;
    }
}

6.在每个树行中找最大值[515]

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList();
        if(root==null) return res;
        
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int max=Integer.MIN_VALUE;
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                max = Math.max(max,node.val);
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            res.add(max);
        }
        return res;
    }
}

7.填充每个节点的下一个右侧节点指针[116]

class Solution {
    public Node connect(Node root) {
        if(root==null) return root;

        Queue<Node> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i=0;i<size;i++){
                Node node = queue.poll();
                if(i<size-1) node.next = queue.peek();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
        }
        return root;
    }
}

8.填充每个节点的下一个右侧节点指针 II[117]

  • 解同上题

9.二叉树的最大深度[104]

  • 层数就是最大深度
class Solution {
    public int maxDepth(TreeNode root) {
        int res = 0;
        if(root==null) return res;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            res++;
        }
        return res;
    }
}

10.二叉树的最小深度[111]

  • 左右子节点都为空时满足最小深度
class Solution {
    public int minDepth(TreeNode root) {
        int res = 0;
        if(root==null) return res;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            res++;
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
                if(node.left==null&&node.right==null){
                    return res;
                }
            }
        }
        return res;
    }
}
举报

相关推荐

力扣刷题-二叉树-二叉树的递归遍历

leetcode算法python数据结构

力扣：二叉树的中序遍历

leetcode

力扣144——二叉树的前序遍历

leetcode算法二叉树深度优先c++

力扣题---二叉树---对称二叉树

leetcode算法动态规划

《二叉树基础》二叉树的遍历

java数据结构算法二叉树

力扣 二叉树的层序遍历

leetcodejava算法

[力扣]二叉树3

leetcode算法深度优先

【leetcode力扣 || 二叉树】

leetcode深度优先算法二叉树

20230502 - 二叉树1 | 二叉树理论基础、二叉树的递归遍历

tcp/ip网络服务器

蓝桥杯-二叉树的后序遍历-力扣

javaleetcodeidea蓝桥杯算法
0 条评论