【算法&数据结构初阶篇】：二叉树

已于 2023-02-08 09:54:44 修改
阅读量242 收藏 1
点赞数 1
分类专栏： Java 数据结构与算法 文章标签： 算法 数据结构 leetcode Powered by 金山文档
于 2023-02-07 10:58:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/studyday1/article/details/128914598
版权

105. 从前序与中序遍历序列构造二叉树

LeetCode:105. 从前序与中序遍历序列构造二叉树

核心点：
1. 前序遍历：根左右 ；中序遍历：左根右

2.从前序遍历中的子树preorder，第一个元素即为根节点， 创建出根节点head,最后用来返回

3.接着就从 中序遍历中的子树inorder，遍历找到根节点对应的索引find,[L2,find)即为左子树元素，(find,R2]即为右子树元素，find - L2的根节点到左子树边界距离长度就等同于中序遍历中根节点到左子树边界距离，从而来 确定左子树的右边界： L1 + find - L2 ，其余边界同理推断

4.然后开始用根节点 head递归去构造head.left head.right左右子树

5. L1 > R1边界溢出，这点很重要容易忽略，会出现 二叉树是一个单边树，即左子树空或者右子树空，此时就会存在越界情况：比如先序 中序 都为[1,2,3] (左子树为空) ，根节点1，中序遍历中索引find=0，再往左找左子树递归就溢出了。head.left = f(preorder, L1 + 1, L1 + find - L2, inorder, L2, find - 1,valueIndexMap); 此时L1 + find - L2 = L1 因为第一轮find跟L2重叠 所以就变成 L1+1,L1 溢出，则需要返回空 
/**
 * Definition for a binary tree node.
 * 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 TreeNode buildTree(int[] preorder, int[] inorder) {
        //提前记录中序遍历的头节点对应索引的Map,用来查询出中序遍历中哪个是根节点，对应的索引，就不用每次递归子树时都要循环查找中序遍历的根节点
        HashMap<Integer,Integer> valueIndexMap = new HashMap<>();
        for(int i = 0; i < inorder.length; i++){
            valueIndexMap.put(inorder[i], i);
        }
        return f(preorder, 0, preorder.length-1, inorder, 0, inorder.length-1, valueIndexMap);
        
    }
    // 有一棵树，先序结果是pre[L1...R1]，中序结果是in[L2...R2]
    // 请建出整棵树返回头节点
    public TreeNode f(int[] preorder, int L1, int R1, int[] inorder, int L2, int R2, HashMap<Integer,Integer> valueIndexMap){
        //存在某些情况下 会越界溢出
        //比如 先序 中序 都为[1,2,3] (左子树为空) 那么确定好根节点1，中序遍历中该根节点在索引find=0，在往左找左子树递归就溢出了。head.left =  f(preorder, L1 + 1, L1 + find - L2, inorder, L2, find - 1,valueIndexMap); 此时L1 + find - L2 = L1  因为第一轮find跟L2重叠 所以就变成L1+1,L1 溢出，返回空
        if(L1 > R1) 
        return null;
        //先序遍历 根左右，索引第一个即为根节点 取出
        TreeNode head = new TreeNode(preorder[L1]);
        //当子树中只有自己的时候则直接返回根节点
        if(L1 == R1)
        return head;
        //从中序遍历中，找到根节点L1对应的索引find ,那么 从[0,find-1]皆为左子树的节点，
        //[find+1,R2]皆为右子树的节点，然后就开始分别左递归，右递归去构建树
        int find = valueIndexMap.get(preorder[L1]);
        //递归左子树：确定先序遍历的左子树左右边界：左边界就是从L1+1,因为L1是根节点，根据中序遍历根节点索引find往左的元素都为左子树元素，find - L2 表示根节点到左子树左边界的距离，那么在先序遍历中根节点加上这个距离就得到左子树的右边界了。 因为两边同个子树长度一定相等。 所以右边界为 L1+find-L2;    而中序遍历的左子树左右边界：就是find节点左侧那一堆数 L2,find-1
        //
        head.left = f(preorder, L1 + 1, L1 + find - L2, inorder, L2, find - 1,valueIndexMap);
        //递归右子树同理
        head.right = f(preorder,L1 + find - L2 + 1, R1, inorder, find + 1, R2,valueIndexMap);
        //最后需要返回根节点
        return head;

    }
}

98. 验证二叉搜索树

LeetCode:98.验证二叉搜索树

代码如下：

/**
 * Definition for a binary tree node.
 * 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 boolean isValidBST(TreeNode root) {
        return process(root).isBST;
    }

    //定义一个类，存放树是否为搜索树、树的最大值、最小值 
    public class info{
        public boolean isBST;
        public int max;
        public int min;
        public info(boolean is, int ma, int mi){
            isBST = is;
            max = ma;
            min = mi;
        }
    }
    //递归树
    public info process(TreeNode x){
        //当前节点空时，则返回null，返回给到上一层去处理
        if(x == null) return null;
        //开始递归左右子树
        info leftInfo = process(x.left);
        info rightInfo = process(x.right);
        //判断是否为搜索树，初始默认为true，后面再判断不满足的条件 再赋值false
        Boolean isBST = true;
        //初始默认当前节点为该节点树的最大值与最小值
        int max = x.val;
        int min = x.val;
        //如果左右子树非空，就分别判断刷新最大值与最小值，左子树的最大值，如果大于当前节点max,其实就是当前节点值，那么max就会刷新，这种情况就不是搜索树，因为左子树是要小于父节点 
        if(leftInfo != null){
            max = Math.max(max, leftInfo.max);
            min = Math.min(min,leftInfo.min);
        }
        if(rightInfo != null){
            max = Math.max(max, rightInfo.max);
            min = Math.min(min,rightInfo.min);
        }
        //1.左右子树非空且isBsT为false 即左右子树为非搜索树，那这个父节点的树也为非搜索树
        if(leftInfo != null && !leftInfo.isBST) isBST = false;
        if(rightInfo != null && !rightInfo.isBST) isBST = false;
        //2.判断左子树是否小于父节点，右子树是否大于父节点
        Boolean leftMaxLessX = leftInfo == null ? true : leftInfo.max < x.val;
        Boolean rightMinMoreX = rightInfo == null ? true : rightInfo.min > x.val;
        //3.当前 左子树小于父节点且右子树大于父节点时 才是搜索树，所以取反情况下则非搜索树
        if(!(leftMaxLessX && rightMinMoreX)) isBST = false;
        //最后返回当前节点三个自定义的信息
        return new info(isBST, max, min);

    }
}

110. 平衡二叉树

LeetCode:110. 平衡二叉树

代码如下：

/**
 * Definition for a binary tree node.
 * 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 boolean isBalanced(TreeNode root) {
        return recur(root) != -1;  //方法一
         // return process(root).isBalanced; //方法二
    }
    //方法一：更优
    private int recur(TreeNode root) {
        if (root == null) return 0;
        int left = recur(root.left);
        if(left == -1) return -1;
        int right = recur(root.right);
        if(right == -1) return -1;
        return Math.abs(left - right) < 2 ? Math.max(left, right) + 1 : -1;
    }

        //方法二：
    // public static class Info {
    //     public boolean isBalanced;
    //     public int height;

    //     public Info(boolean i, int h) {
    //         isBalanced = i;
    //         height = h;
    //     }
    // }
    // public static Info process(TreeNode root) {
    //     if (root == null) {
    //         return new Info(true, 0);
    //     }
    //     Info leftInfo = process(root.left);
    //     Info rightInfo = process(root.right);
    //     int height = Math.max(leftInfo.height, rightInfo.height) + 1;
    //     boolean isBalanced = leftInfo.isBalanced && rightInfo.isBalanced
    //             && Math.abs(leftInfo.height - rightInfo.height) < 2;
    //     return new Info(isBalanced, height);
    // }
}

112. 路径总和

112. 路径总和

代码如下：两种

/**
 * Definition for a binary tree node.
 * 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 boolean hasPathSum(TreeNode root, int targetSum) {//递归
        if(root==null) return false;
        if(root.left==null&&root.right==null&&root.val==targetSum) return true;
        return hasPathSum(root.left,targetSum-root.val) || hasPathSum(root.right,targetSum-root.val);
    }
}
package class07;

public class Code03_PathSum {

    // 测试链接：https://leetcode.com/problems/path-sum
    public static class TreeNode {
        public int val;
        public TreeNode left;
        public TreeNode right;

        TreeNode(int val) {
            this.val = val;
        }
    }

    public static boolean isSum = false;

    public static boolean hasPathSum(TreeNode root, int sum) {
        if (root == null) {
            return false;
        }
        isSum = false;
        process(root, 0, sum);
        return isSum;
    }

    public static void process(TreeNode x, int preSum, int sum) {
        if (x.left == null && x.right == null) {
            if (x.val + preSum == sum) {
                isSum = true;
            }
            return;
        }
        // x是非叶节点
        preSum += x.val;
        if (x.left != null) {
            process(x.left, preSum, sum);
        }
        if (x.right != null) {
            process(x.right, preSum, sum);
        }
    }

//    public static boolean hasPathSum(TreeNode root, int sum) {
//        if (root == null) {
//            return false;
//        }
//        return process(root, sum);
//    }
//
//    public static boolean process(TreeNode root, int rest) {
//        if (root.left == null && root.right == null) {
//            return root.val == rest;
//        }
//        boolean ans = root.left != null ? process(root.left, rest - root.val) : false;
//        ans |= root.right != null ? process(root.right, rest - root.val) : false;
//        return ans;
//    }

}

113. 路径总和 II

113. 路径总和 II

代码如下：两种

/**
 * Definition for a binary tree node.
 * 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<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>>res=new LinkedList<>();
        if(root==null) return res;
        Deque<Integer>path=new ArrayDeque<>();
        dfs(root,targetSum,res,path);
        return res;
    }
    public void dfs(TreeNode root,int targetSum,List<List<Integer>>res,Deque<Integer>path){
        if(root==null) return;// 递归终止条件
        targetSum-=root.val;// 沿途结点必须选择，这个时候要做两件事：1、sum 减去这个结点的值；2、添加到 path 里
        path.addLast(root.val);
        if(root.left==null&&root.right==null&&targetSum==0){
            res.add(new LinkedList<>(path));// path 全局只有一份，必须做拷贝
            path.removeLast(); // 注意：这里 return 之前必须重置
            return;
        }
        dfs(root.left,targetSum,res,path);
        dfs(root.right,targetSum,res,path);
        path.removeLast();// 递归完成以后，必须重置变量
    }
}
package class07;

import java.util.ArrayList;
import java.util.List;

public class Code04_PathSumII {

    // 测试链接：https://leetcode.com/problems/path-sum-ii
    public static class TreeNode {
        public int val;
        public TreeNode left;
        public TreeNode right;

        TreeNode(int val) {
            this.val = val;
        }
    }

    public static List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }
        ArrayList<Integer> path = new ArrayList<>();
        process(root, path, 0, sum, ans);
        return ans;
    }

    public static void process(TreeNode x, List<Integer> path, int preSum, int sum, List<List<Integer>> ans) {
        if (x.left == null && x.right == null) {
            if (preSum + x.val == sum) {
                path.add(x.val);
                ans.add(copy(path));
                path.remove(path.size() - 1);
            }
            return;
        }
        // x 非叶节点
        path.add(x.val);
        preSum += x.val;
        if (x.left != null) {
            process(x.left, path, preSum, sum, ans);
        }
        if (x.right != null) {
            process(x.right, path, preSum, sum, ans);
        }
        path.remove(path.size() - 1);
    }

    public static List<Integer> copy(List<Integer> path) {
        List<Integer> ans = new ArrayList<>();
        for (Integer num : path) {
            ans.add(num);
        }
        return ans;
    }

}

107. 二叉树的层序遍历 II

107. 二叉树的层序遍历 II

代码如下：

/**
 * Definition for a binary tree node.
 * 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<List<Integer>> levelOrderBottom(TreeNode root) {
        if(root == null) return new LinkedList<>();
        //定义一个LinkedList集合返回结果，核心点在于要求自底向上的输出 ans.add(0,list);
        //每次从头链表位置插入，linkedlist是链表结构，效率比arraylist高
        List<List<Integer>> ans = new LinkedList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while(!queue.isEmpty()){
            List<Integer> list = new LinkedList<>();
            int size = queue.size();
            for(int i = 0; i < size; i++ ){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
            }
            
            ans.add(0,list);
        }
    return ans;
    }
}
studyday1
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构初阶数据结构初阶
02-12
初学者在学习数据结构时，通常会遇到一系列基础概念和重要类型，这些都会在"数据结构初阶"的学习中逐步揭示。 首先，我们要理解数据结构的基本概念。数据结构是存储和组织数据的一种方式，它不仅考虑了数据的存储，...
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
数据结构初阶：二叉树
yourfriendyo的博客
11-17 1474
树是n(n≥0)n\;(n≥0)n(n≥0)个元素的有限集。树是递归定义的，任意一个树都是由一个根结点和多个子树构成，而其中每个子树也是由一个根结点和多个子树构成。根结点：每个树有且仅有的一个根结点，即树中最上面的一个结点，根结点无前驱结点。子树：分成M(M≥0)M\;(M≥0)M(M≥0)个互不相交的集合，而每个集合都是一个与树结构类似的子树。如右图所示，根结点AAA下面有三个子树，这三个子树又分别以结点BBB，CCC，DDD为根结点。B。
初阶数据结构：二叉树
qq_71806743的博客
03-02 1092
的数据结构，其有n个有限的节点构成，树结构具有层次性。它的形状颇像一颗颠倒的树，因此而被称为树。2. 我们从最后一个非叶子结点开始，向下调整，调整过后的子树都为堆，一直循环到根结点。对于树结构的初次学习，我们来重点学习二叉树这一结构。我们接下来进行这几个问题的学习。
数据结构与算法初阶8：二叉树链式结构的实现及遍历知识精讲
King_lm_Guard的博客
07-22 494
数据结构与算法初阶8：二叉树遍历方式及层序遍历详解。
初阶数据结构：二叉树（补充扩展）
qq_71806743的博客
03-04 908
当数据量很大时，且为乱序，数据无法一下全部加载到内存中，所以整体排序无法得出最大或最小的前K个数，那么，如何快速得出前K个最大/最小数。思路：我们先建堆，然后将堆顶（堆顶元素总是为最大或最小）的元素与尾部元素交换，size–，然后向下调整，直至堆为空。3. 思路：遇到与配对子树的根节点相同的结点即开始配对，直至遍历完整个树。等比数列求和，得需调整n - log(n + 1)，时间复杂度为O(n)在前面的学习中，我们已经了解到，二叉树的结构由三部分组成。先于数据首部建一个大小为K的。思路：使用层序遍历，
【数据结构初阶】：堆和二叉树
wcsq0523的博客
12-05 1314
【数据结构初阶】：堆和二叉树 文章目录【数据结构初阶】：堆和二叉树1. 树概念及结构1.1 树的概念1.2 树的相关概念1.3 树的表示1.4 树在实际中的运用（表示文件系统的目录树结构）2. 二叉树概念及结构2.1 概念2.2现实中的二叉树：2.3 特殊的二叉树：2.4 二叉树的性质2.5 二叉树的存储结构3. 二叉树的顺序结构及实现3.1 二叉树的顺序结构3.2 堆的概念及结构3.3 堆的实现3.3.1 堆的创建和初始化3.3.2 堆的销毁3.3.3 堆的插入3.3.4 堆的删除3.3.5 堆实现测试
数据结构:链式二叉树初阶
小青菜的博客
03-10 1846
链式二叉树基础
数据结构与算法初阶6：树与二叉树基础知识精讲
King_lm_Guard的博客
07-20 523
数据结构与算法初阶6：树和二叉树基本概念及特性。
【初阶数据结构篇】二叉树基础概念
2301_79849925的博客
07-27 691
树是⼀种非线性的数据结构，它是由 n（n>=0）个有限结点组成⼀个具有层次关系的集合。把它叫做树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。 - 有⼀个特殊的结点，称为根结点，根结点没有前驱结点。 - 除根结点外，其余结点被分成 M(M>0) 个互不相交的集合 T1、T2、……、Tm ，其中每⼀个集合 Ti(1
数据结构初阶：二叉树_struct treenode，2024年最新成功跳槽阿里
2401_83946722的博客
04-20 556
二叉树的每个结点可无子树或有一个子树，但最多有两个子树，分别称为左子树和右子树。二叉树不存在度大于2的结点。同样二叉树的度最大为2。度为0时树为空。度为1时是线性结构，度为2时存在可能有两个子树的结点。二叉树中结点的子树有左右之分，且次序不可颠倒。任意二叉树由以下几种情况复合而成：堆是一种数据结构，他是完全二叉树的一种应用，故堆的底层采用数组作底层结构。需注意，此刻所讨论的堆是一种抽象数据结构，和内存中的堆没有关系。定义一个值的集合k0k1k2kn−1。
C语言实现数据结构算法初阶算法
06-15
在IT领域，掌握数据结构和算法是至关重要的。C语言作为底层编程的首选语言，它提供了直接操作内存的灵活性，因此用C语言实现数据结构和算法可以深入理解这些概念的本质。下面将详细介绍标题和描述中提到的几个核心...
java数据结构和算法
03-04
Java数据结构和算法是编程领域中的核心概念，对于任何想要在Java编程中深入发展的程序员来说，都是必须掌握的基础。这份PDF教程涵盖了这一主题，旨在帮助Java程序员提升技能，实现从初阶到进阶的转变。 数据结构是...
5力扣：最长回文子串
m0_75015083的博客
08-02 87
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
算法第十七天：leetcode242.有效的字母异位词
m0_75068978的博客
08-02 243
如下表所示，您可以直接复制下面网址进入力扣学习，在观看下面的内容之前您一定要先做一遍哦，以便让你印象更加深刻！
LeetCode：2740. 找出分区值（Java 排序）
Cosmoshhhyyy的博客
08-02 142
一道简单的mid题，翻译题目其实就是找出排序后两个相邻数之间的最小差值。
代码随想录算法训练营第三十三天 | 动态规划理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯
weixin_43581681的博客
08-01 142
1. 动态规划基础；2. 背包问题；3. 打家劫舍；4. 股票问题；5. 子序列问题。1. 确定 dp[ i ] 数组及下标含义；2. 确定递推公式；3.确定dp数组如何初始化；4. 确定遍历顺序（背包问题中很重要）；5. 举例推导dp数组。
TypeScript 及算法准备
最新发布
qq_25416827的博客
08-02 605
typescript复制代码function mergeSortedArrays(arr1: number[], arr2: number[]): number[] {typescript复制代码function flattenArray(arr: any[]): any[] {typescript复制代码function flattenArray(arr: any[]): any[] {typescript复制代码function flattenArray(arr: any[]): any[] {
数据结构复习笔记：二叉树与排序算法详解
数据结构复习笔记是一份全面而深入的数据结构学习资料，主要针对数据结构的基础概念、重要数据结构类型以及算法设计与分析展开讲解。该笔记首先阐述了数据结构的发展背景和学习目的，强调了理解和处理现实世界中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值