刷题记录8---验证二叉搜索树+二叉树的层序遍历+从前序与中序遍历序列构造二叉树+二叉树展开为链表+二叉树的最近公共祖先

已于 2022-05-05 16:00:10 修改
阅读量466 收藏
点赞数
分类专栏： 算法和数据结构 文章标签： 数据结构 算法
于 2022-05-05 15:55:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39721240/article/details/124553144
版权
本文介绍了如何利用递归和队列解决验证二叉搜索树和二叉树的层序遍历问题。在验证二叉搜索树时，通过递归检查节点值的范围，确保每个子树都符合搜索树特性。而在进行层序遍历时，利用队列逐层收集节点值。此外，还展示了如何从先序和中序遍历序列构建二叉树，以及如何将二叉树展开为链表。最后，讲解了找到二叉树中两个节点最近公共祖先的方法，通过遍历节点路径找到最近公共祖先。
摘要由CSDN通过智能技术生成

前言

所有题目均来自力扣题库中的hot 100，之所以要记录在这里，只是方便后续复习

98.验证二叉搜索树

题目：
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1：
验证二叉搜索树示意图

输入：root = [2,1,3]
输出：true
示例 2：
输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。
提示：
树中节点数目范围在[1, 104] 内
-231 <= Node.val <= 231 - 1
解题思路：
【递归】根据二叉搜索树的性质：我们要先判断左子树值小于根节点值，右子树值大于根节点值，符合条件的话我们要在判断左子数是否是搜索二叉树，右子树是否为搜索二叉树，因为判断方式一样，这就很容易联想到递归；那递归的中止条件是什么呢？当节点为空时，直接放回True即可；那我们在递归的时候每个根节点的值是会变的，其左子树 和 右子树值的范围也会跟着改变，所以要把这个范围当作参数传入递归函数，当递归左子数时要更新最大值为根节点值，递归右子树时要更新最小值为根节点值
代码（python）：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        # 定义初始的最新小值 和 最大值，注意不是int类型最值了，是正负无穷
        low = float("-inf")
        high = float("inf")
        # 调用递归方法
        return self.test(root, low, high)

    def  test(self, root, low, high):
        #如果当前节点为空，直接返回True即可
        if root is None:
            return True
        # 如果当前节点 值超过了 最小值 和 最大值的范围，直接返回False
        if root.val >= high or root.val <= low:
            return False
        # 递归验证左子数和右子树是否为搜索二叉树
        # 注意要更新最小值或最大值的范围 左子数的最大值变成节点值  右子树的最小值变成节点值
        return self.test(root.left, low, root.val) and self.test(root.right, root.val , high)

代码（java）：

/**
 * 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) {
        ArrayList<Integer> values = new ArrayList<>();
        zhongXu(root, values);
        return isSorted(values);
    }

    public void zhongXu(TreeNode root, ArrayList<Integer> values){
        if(root == null){
            return;
        }
        zhongXu(root.left, values);
        values.add(root.val);
        zhongXu(root.right, values);
    }

    public boolean isSorted(ArrayList<Integer> values){
        for(int i = 0; i < values.size() - 1; i++){
            if (values.get(i) >= values.get(i + 1)){
                return false;
            }
        }
        return true;
    }
}

知识点：

  • python中，可以用float(“inf”)和float(“-inf”)表示正负无穷，而sys.maxsize和-sys.maxsize - 1表示最大int值和最小int值
  • java中，可以用Long.MAX_VALUE和Long.MIN_VALUE表示Long类型的最大最小值，而Integer.MAX_VALUE和Integer.MIN_VALUE表示int类型的最大最小值

原题链接：验证二叉搜索树

102.二叉树的层序遍历

题目：
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
示例 1：
二叉树的层序遍历

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]
解题思路：
【队列】首先想到的思路是先用节点集合把一层的节点存储起来，然后将一层节点值取出来组成一个集合并添加到结果集合中，再把这个集合里的节点替换成下一层节点，可是这样要频繁删除节点集合的值，进一步优化我们可以用队列存储节点，这样边将本层节点依次出队列将值放到集合中，边将该节点的子节点入队列，那这种怎么知道哪些节点是本层的，哪些节点是下一层的呢？可以在每层出队列开始时（此时下一层节点还未入列队）计算一下队列长度，只按这个长度进行出队列，这样就都是本层节点了
代码（python）：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        results = []
        self.test(root, results, 0)
        return results

    def test(self, root, results, level):
        if root is None:
            return
        
        if level >= len(results):
            results.append([root.val])
        else:
            results[level].append(root.val)
        
        self.test(root.left, results, level + 1)
        self.test(root.right, results, level + 1)

代码（java）：

/**
 * 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>> levelOrder(TreeNode root) {
        //定义 结果集合
        ArrayList<List<Integer>> result = new ArrayList<>();
        // 如果当前节点为空，返回空集合即可
        if(root == null){
            return result;
        }
        //定义队列，用来存放每层的节点
        Queue<TreeNode> myQueue = new LinkedList<>();
        //先把根节点放入队列中
        myQueue.offer(root);
        //从队列中取值，直到队列为空
        while(myQueue.isEmpty() == false){
            // 先计算一下当前队列的长度，即计算一下这一层有多少个节点，用来作层与层之间的分割
            int curSize = myQueue.size();
            // 定义当前集合
            ArrayList<Integer> curList = new ArrayList<>();
            // 把这一层的节点依次拿出，并将节点的值添加到当前集合中，再将左节点和右节点添加都队列中用于下一层的遍历，注意判断左右节点是否为空
            for(int i = 0; i < curSize; i ++){
                TreeNode curNode = myQueue.poll();
                curList.add(curNode.val);
                if (curNode.left != null){
                    myQueue.offer(curNode.left);
                }
                if (curNode.right != null){
                    myQueue.offer(curNode.right);
                }
            }
            // 将当前集合添加到结果集合中
            result.add(curList);
        }
        return result;
    }
}

知识点：

  • java中可以用LinkedList当作队列，linkedlist.offer(val)表示入队列，linkedlist.poll()表示出队列，linkedlist.isEmpty()判断对列是否为空
  • python中可以用Queue()定义队列，但是需要导报from queue import Queue，入队列put(val)，出队列get()

原题链接：二叉树的层序遍历

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

题目：
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。
示例 1:
从前序与中序遍历序列构造二叉树

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]
示例 2:
输入: preorder = [-1], inorder = [-1]
输出: [-1]
解题思路：
【递归】二叉树的题可以先考虑递归，我们先确定根节点，然后确定左子数和右子树有哪些节点，再用递归去构造左右子树即可；怎么确定根节点？根据先序遍历的顺序：根-左-右，先序遍历序列第一个值即为根节点的值；怎么确定左子数和右子树有哪些呢？根据中序遍历的顺序：左-根-右，我们在中序遍历序列中找到根节点，那他左边的就是左子数的节点，右边的就是右子树的节点，我们可以计算出左右子树的节点个数，根据左右子树的个数我们就可以把先序和中序序列进行有效的切分并进行左右子树的递归，与其进行序列的切分倒不如用左右边界值控制有效范围，减少时间复杂度；那递归的中止条件是什么呢？即左右子树个数为0的即左右边界值无效的情况，返回空节点即可
代码（python）：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):

    inorderIndex = {}

    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        if preorder is None or len(preorder) == 0:
            return None
        
        self.getInorderIndex(inorder)
 
        return self.myBuildTree(preorder, inorder, 0, len(preorder) - 1, 0, len(inorder) - 1)

    def myBuildTree(self, preorder, inorder, preorder_left, preorder_right, inorder_left, inorder_right):
        """
        递归方法
        通过先序遍历的第一个位置确定出根节点
        通过根节点在中序遍历中的位置，左侧部分为左子树，右侧部分为右子树
        分别将左子树和右子树通过递归的方式进行构造数，并赋给根节点的左右节点
        """
        #如果先序遍历列表的左边界大于右边界，直接返回
        if preorder_left > preorder_right:
            return
        #如果先序遍历列表的左边界等于右边界，说明只有一个节点，该节点没有子节点，直接新建节点赋值返回
        if preorder_left == preorder_right:
            return TreeNode(preorder[preorder_left])
        #前序遍历的第一个值即左边界值就是 根节点，创建根节点
        root = TreeNode(preorder[preorder_left])
        #通过根节点的值在中序遍历中找到该位置
        index = self.inorderIndex[preorder[preorder_left]]
        #计算出左子树的节点个数
        left_number = index - inorder_left
        #递归得到左子树并赋给根节点  通过左子树的个数得到左子树前序遍历的边界范围，通过根节点在中序遍历的位置得到左子树的中序遍历的边界范围
        root.left = self.myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + left_number, inorder_left, index - 1)
         #递归得到右子树并赋给根节点  通过左子树的个数得到右子树前序遍历的边界范围，通过根节点在中序遍历的位置得到右子树的中序遍历的边界范围
        root.right = self.myBuildTree(preorder, inorder, preorder_left + left_number + 1, preorder_right,index + 1, inorder_right)

        return root


    def getInorderIndex(self, inorder):
        """
        获取到中序遍历数组的索引与节点的对应关系 --节点:索引 
        放到属性字典里
        """
        for i in range(0, len(inorder)):
            self.inorderIndex[inorder[i]] = i

代码（java）：

/**
 * 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) {
        //调用递归函数
      return test(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }

    public TreeNode test(int[] preorder, int pl, int pr, int[] inorder, int il, int ir){
        // 当先序遍历的左边界值大于右边界 或 中序遍历的左边界大于右边界，说明当前树点为空
        if(pl > pr || il > ir){
            return null;
        }
        // 当先序遍历或中序遍历的左边界和右边界相等，说明，当前树只有一个节点，直接构造一个节点返回即可
        if(pl == pr || il == ir ){
            return new TreeNode(preorder[pl]);
        }
        //先序遍历有效范围第一位即根节点  根据先序遍历的性质
        int rootValue = preorder[pl];
        TreeNode root = new TreeNode(rootValue);
        // 在中序遍历有效位范围内找到根节点，
        int rootIndex = il;
        for (int i = il; i <= ir; i ++){
            if(inorder[i] == rootValue){
                rootIndex = i;
                break;
            }
        }
        //定义左右子树的节点个数   因为中序遍历有效范围内根节点左边的节点都是左子数，右边的节点都是右子树
        int leftNum = rootIndex - il;
        int rightNum = ir - rootIndex;
        // 通过递归的方式构造左右子树并赋给根节点 通过控制有效范围达到传递子树的先序遍历和中序遍历效果
        root.left = test(preorder, pl + 1, pl + leftNum, inorder, il, rootIndex - 1);
        root.right = test(preorder, pl + leftNum + 1, pl + leftNum + rightNum, inorder, rootIndex + 1, ir);
        return root;
    }
}

知识点：

  • 无

原题链接：从前序与中序遍历序列构造二叉树

114.二叉树展开为链表

题目：
给你二叉树的根结点 root ，请你将它展开为一个单链表：

展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
展开后的单链表应该与二叉树 先序遍历 顺序相同。

示例 1：
二叉树展开为链表

输入：root = [1,2,5,3,4,null,6]
输出：[1,null,2,null,3,null,4,null,5,null,6]
示例 2：

输入：root = []
输出：[]
示例 3：

输入：root = [0]
输出：[0]
解题思路：
【链表遍历】由于和先序遍历顺序相同，我们可以先序遍历二叉树，将节点存放在列表里，然后将他们拼成链表，但这样空间复杂度为On；要想空间复制度为O1，需要原地操作，将其展开为单链表，其实就是将所有左子数插入右子树对应的位置，我们可以遍历二叉树，如果有左子树，就让其插入右子树中；怎么插入右子树呢，我们先将右子树挂在左子数上，挂在哪里呢？根据先序遍历的顺序，右子树的前一个节点应该是左子数的最右节点，就挂在最右节点上，然后将左子数移到原右子树的位置，这样就完成了左子数的插入，注意的是原左子数要置为空
代码（python）：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):

    nodes = []

    def flatten(self, root):
        """
        :type root: TreeNode
        :rtype: None Do not return anything, modify root in-place instead.
        """

        if root is None:
            return None

        self.pre(root)

        head = self.nodes[0]
        tail = head

        for i in range(0, len(self.nodes) - 1):
            tail.left = None
            tail.right = self.nodes[i + 1]
            tail = tail.right
        
        return head


    def pre(self, root):
        if root is None:
            return
        
        self.nodes.append(root)
        self.pre(root.left)
        self.pre(root.right)

代码（java）：

/**
 * 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 void flatten(TreeNode root) {
       //定义索引节点
       TreeNode cur  = root;
       // 遍历怎个二叉树
       while(cur != null){
           //如果存在左子数
            if (cur.left != null){
                //将其左子树存起来
                TreeNode next = cur.left;
                // 找到左子树的最右节点 即右子树的前节点
                TreeNode pre = next;
                while (pre.right != null){
                    pre = pre.right;
                }
                //将 右子树挂在前节点上（也是左子树）
                pre.right = cur.right;
                // 将当前节点的左子数 置为空
                cur.left = null;
                // 将当前节点右子树 置为 原来存的左子树
                cur.right = next;
            }
            // 滑动索引节点 （包括左子数处理完的情况 与 左子数为空不需要处理的情况）
            cur = cur.right;
       }

    }
}

知识点：

  • 无

原题链接：二叉树展开为链表

236.二叉树的最近公共祖先

题目：
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
示例 1：
二叉树的最近公共祖先示意图

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。
示例 2：
输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出：5
解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。
示例 3：
输入：root = [1,2], p = 1, q = 2
输出：1

解题思路：
【链表遍历】我们可以从两个节点向上查找其到根节点路径，第一个相交的节点便是最近公共祖先；但是向上查找需要知道各个节点的父节点怎么办？我们可以先遍历一遍二叉树，通过字典（子节点-父节点）的存储各个节点的父节点；这样我们可以先用列表存储一个节点路径（要保证有序，不能用hash结构），在寻找第二个节点的路径时判断是否在第一个路径中，若在则该节点就是相交节点即结果值
代码（python）：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):


    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        # 定义字典，用来存储每个节点的父节点
        parents = dict()
        self.get_parents(root, parents)
        # 根据字典，从p节点开始到根节点，依次把父节点放入列表中
        p_list = list()
        while p:
            p_list.append(p)
            p = parents.get(p, None)
        # 根据字典，从q节点开始遍历其父节点，第一个在列表中节点就是最近公共祖先
        while q not in p_list:
            q = parents.get(q, None)
        return q

    def get_parents(self, root, parents):
        # 如果节点为空 直接返回
        if root is None:
            return
        # 如果有左节点，将左节点的父节点放入字典中
        if root.left:
            parents[root.left] =  root
        # 如果有右节点，将右节点的父节点放入字典中
        if root.right:
            parents[root.right] = root
        # 递归寻找出左右子数的各个节点的父节点
        self.get_parents(root.left, parents)
        self.get_parents(root.right, parents)

代码（java）：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {

    public HashMap<Integer, TreeNode> parents = new HashMap<>();
    
    public void dfs(TreeNode root){
        if (root.left != null){
            this.parents.put(root.left.val, root);
            dfs(root.left);
        }
        if (root.right != null){
            this.parents.put(root.right.val, root);
            dfs(root.right);
        }
    }

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        dfs(root);
        ArrayList<Integer> pList = new ArrayList<>();

        while(p.val != root.val){
            pList.add(p.val);
            p = this.parents.get(p.val);
        }
        pList.add(p.val);

        while(q.val != root.val){
            if (pList.contains(q.val)){
                return q;
            }
            q = this.parents.get(q.val);
        }

        return root;
    }
}

知识点：

  • python中可以用dict.get(key, default)，从字典中获取值，若没有该键则返回default值

原题链接：二叉树的最近公共祖先

热巴的小哥哥
关注
专栏目录
NLP自然语言处理系列-算法基础-K 个一组翻转链表 验证二叉搜索树 从前序与中序遍历序列构造二叉树
段智华的博客
05-09 225
NLP自然语言处理系列-算法基础-K 个一组翻转链表 验证二叉搜索树 K 个一组翻转链表 K 个一组翻转链表 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 穿针引线 # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): #
【二叉树】详解 树的遍历 (前序/中序/后序/层序) (递归+迭代)
闻韶
07-29 4200
LeetCode - 探索卡片 - 二叉树 - 一 - 树的遍历
通过中序和先序/后序序列创建二叉树
csdn_edition的博客
11-22 6855
在二叉树的相关题目中,我们经常会碰到这样的问题，给出一颗二叉树的前序遍历和中序遍历，或者是给出它的后序遍历和中序遍历，让我们画出这个二叉树或者是用代码实现如何用上面两种情况来创建这个二叉树。 首先我们来看看给出先序遍历序列和中序遍历序列如何画出这颗二叉树： 首先，先序遍历序列中的第一个字母肯定是这颗二叉树的根节点，然后在中序遍历的序列中找到这个根节点，以这个根节点作为分割，在中序遍历序列中找到二叉树根节点的左右子树。 如下图所示： 接着我们将左子树的先序遍历序列和中序遍历序列单独拿出来研究，跟上一步一样
二叉树的层序遍历
Mr Liu的博客
07-18 2566
今天来看一道二叉树的高频面试题，在面试中，对于树的考核基本上就是针对二叉树的一些操作了，比如：二叉树的前序、中序、后序、层序遍历，镜像二叉树，对称二叉树，二叉树的第一个公共父节点，二叉树的深度的等等。因此，平时碰上二叉树的题就要多留意一下。 题目描述　　 输出一棵二叉树层序遍历的结果。 思路　　 层序遍历就是从上往下按顺序依次遍历一棵树。按顺序也就是先进先出的规律，因此可以借助一个辅助队列，首先将根节点加入队列，然后循环判断队列是否为空，在队列不为空的情况下，首先访问队列的首元素，随后将首元素出列，如果左右
JavaScript：leetcode_236. 二叉树的最近公共祖先（1. 层序遍历 + 二叉树任意遍历方法 2. 二叉树遍历 + 动态规划）
Eighteen Z
05-10 350
题目说明 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x， 满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4] 示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释
精选力扣500题 第46题 LeetCode 105. 从前序与中序遍历序列构造二叉树【c++/java详细题解】
林深不见鹿 的博客
06-29 3967
目录1、题目2、思路3、c++代码4、java代码 1、题目 根据一棵树的前序遍历与中序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 2、思路 (递归) O(n)O(n)O(n) 二叉树前序遍历的顺序为：根左右 二叉树中序遍历的顺序为：左根右 递归建立整棵二叉树：先创
【二叉树】前序遍历构造二叉搜索树
豪冷的博客
06-30 958
题目 给定一个整数数组 它表示BST(即二叉搜索树 )的 先序遍历 构造树并返回其根节点
图+查找+排序+循环链表+循环链表+数组+广义表+二叉树与树的转换+哈夫曼树.pptx
11-10
这份名为"图+查找+排序+循环链表+循环链表+数组+广义表+二叉树与树的转换+哈夫曼树.pptx"的文档涵盖了多个关键知识点，下面将对这些主题进行详细解释。 1. **数组**：数组是最基本的数据结构，它允许存储具有相同...
c代码-用前序序列和中序序列构建链表二叉树,并且按照层次遍历
07-16
根据前序和中序序列构造二叉树** 由于前序遍历的第一个元素是根节点，而中序遍历中根节点将左右子树分隔开，我们可以用这两个序列来构建二叉树。具体步骤如下： - 找到中序序列中前序序列的第一个元素，这个元素...
由二叉树的先序序列和中序序列构建二叉树
qq_40691051的博客
10-20 4051
构造思想： 假设当前处理先序序列pre的处理区间是[a,b],中序序列in处理的区间是[c,d]。 例如： string pre = "123456789"; string in = "325416879"; pre的处理区间是[0,8],中序序列in处理的区间是[0,8] 若a<b,则以pre[a]建立二叉树的根结点，然后搜索in[c,d],找到in[i] == pre[a]的位置i...
leetcode：255 验证前序遍历序列二叉搜索树
OceanStar的博客
08-04 551
为了使空间复杂度为常量，我们不能使用 stack，所以直接修改 preorder，将 low 值存在 preorder 的特定位置即可。给定一个整数数组，你需要验证它是否是一个二叉搜索树正确的先序遍历序列。你可以假定该序列中的数都是不相同的。输入: [5,2,6,1,3]输入: [5,2,1,3,6]...
依照先序序列和中序序列建立二叉树
日月
02-02 802
数据结构上机测试4.1:二叉树的遍历与应用1Time Limit: 1000MS Memory Limit: 65536KBProblem Description输入二叉树的先序遍历序列和中序遍历序列，输出该二叉树的后序遍历序列。Input第一行输入二叉树的先序遍历序列；第二行输入二叉树的中序遍历序列。Output输出该二叉树的后序遍历序列。Example InputABDCEF BDAECF#i...
找最近公共祖先，将二叉搜索树转换为双向链表，根据先序和中序结果构造二叉树(不含空节点），将先序结果转为字符串
AIJXB的博客
04-26 189
1.给定两个数，找到其公共的最近祖先 题目如上，需要注意的是，节点本身也可以是自己的祖先。 例如，7和2的公共祖先就是2 6和4的公共祖先就是5，而不是3，因为3不是最近的 首先的思路就是，通过遍历二叉树，如果通过一个节点，可以找到这两个值，说明这个节点就是一个公共祖先，但问题是，我们不知道这个节点是不是她的最近祖先。我们分析可以得出，只要这两个要找的节点分别位于：根节点，左子树，右子树中的任意...
二叉树的前序、中序、后序和层次遍历 & 二叉搜索树的插入、查找操作
Runner1st的博客
03-14 479
文章目录树的建立前序遍历方法一：递归方法二：使用栈方法三：使用栈中序遍历后序遍历层次遍历 树的建立 首先，先建立起二叉树的类： public abstract class BinaryTree { public class TreeNode{ int data; TreeNode left; TreeNode right; public TreeNode(int data){...
根据二叉树的前序遍历和中序遍历构造二叉树
antchow-
09-12 1010
题：给出某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列pre：{1,2,4,7,3,5,6,8}和中序遍历序列in：{4,7,2,1,5,3,8,6}，则重建二叉树并返回。思路：令pi=pre[0]，由二叉树的前序遍历特性可知pi为二叉树的根节点root，遍历in，得到in[j]==pi的下标j，由二叉树的前序遍历和中
根据二叉树的先序遍历和中序遍历构建二叉树
霜叶的博客
07-30 2926
问题：根据二叉树的先序和中序构建二叉树 思路：每次根据先序和中序顺序确定根节点和相应的左右子树，再分别对左右子树进行递归确定 程序实现： #include &lt;iostream&gt; using namespace std; typedef struct Btree { int num; struct Btree *lchild; struct Btree...
根据二叉树先序遍历和中序遍历构建二叉树
热门推荐
李文龙的博客
04-24 2万+
欢迎使用 Cmd Markdown 编辑阅读器 采用递归分治的思想，将一个大问题划分成子问题， 对于本题，根据二叉树先序遍历和中序遍历构建二叉树，思路： 我们可以求得根节点左子树的先序和中序序列，以及右子树的先序和中序序列 此问题变成了根据左子树的先序和序列构建左子树的二叉树，根据右子树的先序和中序序列构建右子树的二叉树问题得以分解成子问题 ​​ 令先序序列和中序序列在数组中连续存放。...
刷题总结：二叉树的中序/前序遍历、二叉搜索（查找）树的插入/搜索、二叉树的镜像/翻转二叉树——使用python
林风风
11-17 315
KW46/20：二叉树涉及的内容还挺多呢，这周再练习几个题目，加深对递归思想的理解。 第一题：二叉树的中序遍历，给定一个二叉树的根节点，返回它的中序遍历 思路：中序遍历是左根右，按照递归的思想，依次左子树的中序遍历，res.appen(root.val)，右子树的中序遍历。递归出口是根节点为空，返回None。 代码： class Solution: def inorderTraversal(self, root: TreeNode) -> List[int]: res =
java建树输出父节点,二叉树建树（层序+中序）
weixin_39885383的博客
03-10 187
题目描述给一棵二叉树的层序遍历序列和中序遍历序列，求这棵二叉树的先序遍历序列和后序遍历序列。输入每个输入文件中一组数据。第一行一个正整数N(1<=N<=30)，代表二叉树的结点个数(结点编号为1~N)。接下来两行，每行N个正整数，分别代表二叉树的层序遍历序列和中序遍历序列。数据保证序列中1~N的每个数出现且只出现一次。输出输出一行，包含N个正整数，代表二叉树的先序遍历序列。每行末尾不输...
全面掌握二叉树遍历与操作：前序、中序、后序及层序
二叉树遍历算法是计算机科学中非常重要的基础知识点，它们在很多高级数据结构和算法中都有应用，例如二叉搜索树、堆排序、哈夫曼树等。掌握这些基本操作对于深入理解树形结构和后续的数据结构学习至关重要。在实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值