BST Mock

已于 2024-04-19 14:02:11 修改
阅读量977 收藏 8
点赞数 27
文章标签： 算法 leetcode 职场和发展
于 2024-04-14 07:34:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65279006/article/details/137661672
版权

700,98

 530,501,236

235,701,450

669，108，538

700. Search in a Binary Search Tree

Easy

You are given the root of a binary search tree (BST) and an integer val.

Find the node in the BST that the node's value equals val and return the subtree rooted with that node. If such a node does not exist, return null.

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null || root.val == val) {
            return root;
        }
        if (val < root.val) {
            return searchBST(root.left, val);
        } else {
            return searchBST(root.right, val);
        }
    }
}

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null) {
            return null;
        }
        while (root != null) {
            if (val < root.val) {
                root = root.left;
            } else if (val > root.val) {
                root = root.right;
            } else {
                return root;
            }
        }
        return null;
    }
}
class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null || root.val == val) {
            return root;
        }
        TreeNode left = searchBST(root.left, val);
        if (left != null) {
            return left;
        }
        return searchBST(root.right, val);
    }
}

98. Validate Binary Search Tree

Medium

Given the root of a binary tree, determine if it is a valid binary search tree (BST).

A valid BST is defined as follows:

  • The left 

    subtree

     of a node contains only nodes with keys less than the node's key.
  • The right subtree of a node contains only nodes with keys greater than the node's key.
  • Both the left and right subtrees must also be binary search trees.
class Solution {
    long pre = Long.MIN_VALUE;

    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        boolean left = isValidBST(root.left);
        if (!left) {
            return false;
        }
        if (pre >= root.val) {
            return false;
        }
        pre = root.val;
        boolean right = isValidBST(root.right);
        return right;
    }
}

class Solution {
    long pre = Long.MIN_VALUE;

    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        boolean left = isValidBST(root.left);
        if (pre >= root.val) {
            return false;
        }
        pre = root.val;
        boolean right = isValidBST(root.right);
        return left && right;
    }
}
class Solution {
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return false;
        }
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode cur = root;
        Long pre = Long.MIN_VALUE;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                TreeNode pop = stack.pop();
                if (pre >= pop.val) {
                    return false;
                }
                pre = (long) pop.val;
                cur = pop.right;
            }
        }
        return true;
    }
}

530. Minimum Absolute Difference in BST

Easy

Given the root of a Binary Search Tree (BST), return the minimum absolute difference between the values of any two different nodes in the tree.

class Solution {
    public int getMinimumDifference(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode cur = root;
        TreeNode pre = null;
        int ans = Integer.MAX_VALUE;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                TreeNode pop = stack.pop();
                if (pre != null) {
                    ans = Math.min(pop.val - pre.val, ans);
                }
                pre = pop;
                cur = pop.right;
            }
        }
        return ans;
    }
}
class Solution {
    int ans = Integer.MAX_VALUE;
    TreeNode pre = null;

    public int getMinimumDifference(TreeNode root) {
        if (root == null) {
            return 0;
        }
        getMinimumDifference(root.left);
        if (pre != null) {
            ans = Math.min(ans, root.val - pre.val);
        }
        pre = root;
        getMinimumDifference(root.right);
        return ans;
    }
}

501. Find Mode in Binary Search Tree

Easy

Given the root of a binary search tree (BST) with duplicates, return all the mode(s) (i.e., the most frequently occurred element) in it.

If the tree has more than one mode, return them in any order.

Assume a BST is defined as follows:

  • The left subtree of a node contains only nodes with keys less than or equal to the node's key.
  • The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
  • Both the left and right subtrees must also be binary search trees.
class Solution {
    public int[] findMode(TreeNode root) {
        int count = 0;
        int maxCount = 0;
        TreeNode pre = null;
        List<Integer> list = new LinkedList<>();
        if (root == null) {
            return null;
        }
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                cur = stack.pop();
                if (pre != null) {
                    if (pre.val == cur.val) {
                        count = count + 1;
                    } else {
                        count = 1;
                    }
                } else {
                    count = 1;
                }
                if (count > maxCount) {
                    maxCount = count;
                    list.clear();
                    list.add(cur.val);
                } else if (count == maxCount) {
                    list.add(cur.val);
                }
                pre = cur;
                cur = cur.right;
            }
        }
        return list.stream().mapToInt(Integer::intValue).toArray();
    }
}

class Solution {
    public int[] findMode(TreeNode root) {
        int count = 0;
        int maxCount = 0;
        TreeNode pre = null;
        List<Integer> list = new LinkedList<>();
        if (root == null) {
            return null;
        }
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                cur = stack.pop();
                if (pre == null || cur.val != pre.val) {
                    count = 1;
                } else {
                    count++;
                }
                if (count > maxCount) {
                    maxCount = count;
                    list.clear();
                    list.add(cur.val);
                } else if (count == maxCount) {
                    list.add(cur.val);
                }
                pre = cur;
                cur = cur.right;
            }
        }
        return list.stream().mapToInt(Integer::intValue).toArray();
    }
}

236. Lowest Common Ancestor of a Binary Tree

Medium

Topics

Companies

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) { // 递归结束条件
            return root;
        }

        // 后序遍历
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);

        if(left == null && right == null) { // 若未找到节点 p 或 q
            return null;
        }else if(left == null && right != null) { // 若找到一个节点
            return right;
        }else if(left != null && right == null) { // 若找到一个节点
            return left;
        }else { // 若找到两个节点
            return root;
        }
    }
}

235. Lowest Common Ancestor of a Binary Search Tree

Medium

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while (root != null) {
            if(root.val<p.val&&root.val<q.val){
                root = root.right;
            }else if(root.val>p.val&&root.val>q.val){
                root = root.left;
            }else {
               break;
            }
        }
        return root;
    }
}
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
        if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
        return root;
    }
}

701. Insert into a Binary Search Tree

Medium

You are given the root node of a binary search tree (BST) and a value to insert into the tree. Return the root node of the BST after the insertion. It is guaranteed that the new value does not exist in the original BST.

Notice that there may exist multiple valid ways for the insertion, as long as the tree remains a BST after insertion. You can return any of them.

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if (root == null) {
            return new TreeNode(val);
        }
        if (val < root.val) {
            root.left = insertIntoBST(root.left, val);
        } else if (val > root.val) {
            root.right = insertIntoBST(root.right, val);
        }
        return root;
    }
}
class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if (root == null) {
            return new TreeNode(val);
        }
        TreeNode curNode = root;
        TreeNode pre = root;
        while (curNode != null) {
            pre = curNode;
            if (val < curNode.val) {
                curNode = curNode.left;
            } else if (val > curNode.val) {
                curNode = curNode.right;
            } else {
                return root;
            }
        }
        if (val < pre.val) {
            pre.left = new TreeNode(val);
        } else {
            pre.right = new TreeNode(val);
        }
        return root;
    }
}

450. Delete Node in a BST

Medium

Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.

Basically, the deletion can be divided into two stages:

  1. Search for a node to remove.
  2. If the node is found, delete the node.
class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        if (root == null) return root;
        if (root.val == key) {
            if (root.right == null) {
                return root.left;
            } else {
                TreeNode cur = root.right;
                while (cur.left != null) {
                    cur = cur.left;
                }
                cur.left = root.left;
                root = root.right;
                return root;
            }
        }
        if (key < root.val) root.left = deleteNode(root.left, key);
        if (key > root.val) root.right = deleteNode(root.right, key);
        return root;
    }
}
class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        if (root == null) return null;

        if (root.val > key) {
            root.left = deleteNode(root.left,key);
        } else if (root.val < key) {
            root.right = deleteNode(root.right,key);
        } else {
            if (root.left == null) return root.right;
            if (root.right == null) return root.left;
            TreeNode tmp = root.right;
            while (tmp.left != null) {
                tmp = tmp.left;
            }
            root.val = tmp.val;
            root.right = deleteNode(root.right,tmp.val);
        }
        return root;
    }
}
class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        //1.找到待删除节点
        //2.只有一个孩子的情况，直接托付给父节点。编写托孤方法
        //3.左右孩子都没有用2里的处理逻辑就可以了
        //4.左右孩子都有
        //左右孩子都有，则找到待删除节点的后继节点，记为S，其父节点记为SP
        //若S与待删除节点相邻，即后继节点是他的孩子，则直接将后继孩子节点S继承自己位置，将S托付给Parent
        //若后继节点不是他的孩子，则先把这个孩子节点的孩子托付给这个孩子的父亲SP，再让这个孩子顶替自己位置
        if (root == null) {
            return null;
        }
        TreeNode curNode = root;
        TreeNode parentNode = null;
        //找到需要删除的节点
        while (curNode != null) {
            if (key < curNode.val) {
                parentNode = curNode;
                curNode = curNode.left;
            } else if (key > curNode.val) {
                parentNode = curNode;
                curNode = curNode.right;
            } else {
                break;
            }
        }
        //没有找到
        if (curNode == null) {
            return root;
        }
        //如果只有一个孩子，直接把孩子托付给父节点（所以要记录父节点）
        if (curNode.left == null || curNode.right == null) {
            TreeNode newChild = (curNode.left == null) ? curNode.right : curNode.left;
            if (parentNode == null) {
                root = newChild;  // 这里处理如果删除的是根节点的情况
            } else {
                shift(parentNode, curNode, newChild);
            }
        } else {
            //左右孩子都有
            //4.1找到删除节点的后继(findPrePost里有)，这里一定有右子树，所以找后继的代码用不完
            TreeNode s = curNode.right;
            TreeNode sParent = curNode;
            while (s.left != null) {
                sParent = s;
                s = s.left;
            }
            //4.2后继节点不是待删除节点的孩子，则需要先处理掉后继节点的孩子，再让他继承
            if (curNode.right != s) {
                shift(sParent, s, s.right);//不可能是s.left因为代码如果能执行到这里，就只会有右孩子，因为s.left比s更小
                s.right = curNode.right;
            }
            //4.3后继节点取代被删除节点
            if (parentNode == null) {
                root = s;
            } else {
                shift(parentNode, curNode, s);
            }
            s.left = curNode.left;//之前没有左孩子，现在有左孩子，顶替掉的要长兄如父

        }
        return root;
    }

    //编写一个托孤方法
    //将待删除节点的孩子节点托付给父节点，顶替掉自己的位置
    private void shift(TreeNode parentNode, TreeNode deleteNode, TreeNode child) {
        if (deleteNode == parentNode.left) {
            parentNode.left = child;
        } else {
            parentNode.right = child;
        }
    }
}

669. Trim a Binary Search Tree

Medium

Given the root of a binary search tree and the lowest and highest boundaries as low and high, trim the tree so that all its elements lies in [low, high]. Trimming the tree should not change the relative structure of the elements that will remain in the tree (i.e., any node's descendant should remain a descendant). It can be proven that there is a unique answer.

Return the root of the trimmed binary search tree. Note that the root may change depending on the given bounds.

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if (root == null) {
            return null;
        }
        while (root != null && (root.val < low || root.val > high)) {
            if (root.val < low) {
                root = root.right;
            } else if (root.val > high) {
                root = root.left;
            }
        }
        TreeNode cur = root;
        while(cur!=null) {
            while (cur.left != null && cur.left.val < low) {
                cur.left = cur.left.right;
            }
            cur = cur.left;
        }
        cur=root;
        while (cur!=null) {
            while (cur.right != null && cur.right.val > high) {
                cur.right = cur.right.left;
            }
            cur = cur.right;
        }
        return root;
    }
}
class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if (root == null) {
            return null;
        }
        if (root.val < low) {
            return trimBST(root.right, low, high);
        }
        if (root.val > high) {
            return trimBST(root.left, low, high);
        }
        root.left = trimBST(root.left, low, high);
        root.right = trimBST(root.right, low, high);
        return root;
    }
}

108. Convert Sorted Array to Binary Search Tree

Easy

Given an integer array nums where the elements are sorted in ascending order, convert it to a 

height-balanced

 binary search tree.

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        TreeNode root = traversal(nums, 0, nums.length - 1);
        return root;
    }
    private TreeNode traversal(int[] nums, int left, int right) {
        if (left > right) {
            return null;
        }
        int mid = (left + right) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = traversal(nums, left, mid - 1);
        root.right = traversal(nums, mid + 1, right);
        return root;
    }
}

538. Convert BST to Greater Tree

Medium

Given the root of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus the sum of all keys greater than the original key in BST.

As a reminder, a binary search tree is a tree that satisfies these constraints:

  • The left subtree of a node contains only nodes with keys less than the node's key.
  • The right subtree of a node contains only nodes with keys greater than the node's key.
  • Both the left and right subtrees must also be binary search trees.
class Solution {
    int pre = 0;
    int sum = 0;

    public TreeNode convertBST(TreeNode root) {
        inorderTraversal(root);
        return root;
    }

    private void inorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        inorderTraversal(root.right);
        sum = pre + root.val;
        pre = sum;
        root.val = sum;
        inorderTraversal(root.left);
    }
}
class Solution {
    public TreeNode convertBST(TreeNode root) {
         if (root == null) {
            return null;
        }
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode cur = root;
        int sum = 0;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.right;
            } else {
                cur = stack.pop();
                sum = sum + cur.val;
                cur.val = sum;
                cur = cur.left;
            }
        }
        return root;
    }
}

陈风凌
关注
  • 27
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
BST纠偏调试步骤
02-28
BST纠偏调试步骤
bst.rar_bst
09-22
BST的定义，非常标准，非常值得参考，，对于入门的同学很有用
【LeetCode】第一次mock interview
keke今天又学算法了
07-22 278
653 - Two Sum IV - Input is a BST https://leetcode.com/problems/two-sum-iv-input-is-a-bst/ 第一题edge case没过，心想着找到target就是在现在traverse的node的value上找到其与target的相差，然后在整个树里找相差，虽然时间是慢了点，但是就是我当时能想出来的唯一办法了orz。。结果...
Dynamic Programing Mock (1)
weixin_65279006的博客
04-08 595
【代码】Dynamic Programing Mock (1)
Mocking JMS infrastructure with MockRunner to favour testing
iushnauh的专栏
05-19 176
From Marco Tedone (http://tedone.typepad.com/blog/2011/07/mocking-spring-jms-with-mockrunner.html)   This article shows *one* way to mock the JMS infrastructure in a Spring JMS application. This al...
[leetcode]449. Serialize and Deserialize BST序列化反序列化BST(尽量紧凑)
weixin_30480651的博客
10-21 99
Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be...
ROS之choro功能包
热门推荐
zhangrelay的专栏
07-27 3万+
使用choro可以快速查找管理功能包，类似ubuntu的apt。 非常方便快捷。 如下： C:\ros_ws>choco search ros-foxy-desktop Chocolatey v0.10.15 ros-foxy-desktop 20201211.0.0.2104300001 1 packages found. 简洁版： ros-catkin-tools 0.0.1.1903221831 ros-cmake 3.11.4.1809242322 ros-colcon-too
lightGBM实战
qq_56591814的博客
01-15 5691
文章目录一、使用LGBMClassifier对iris进行训练1.1 使用lgb.LGBMClassifier1.1.2使用pickle进行保存模型，然后加载预测1.1.3 使用txt和json保存模型并加载1.2使用原生的API进行模型训练和预测1.2.2 使用txt/json格式保存模型1.2.3 使用pickle进行保存模型三、任务3 分类、回归和排序任务3.1使用 make_classification生成二分类数据进行训练3.1.1 sklearn接口3.1.2 原生train接口3.2使用 ma
教育项目之前端模块（vue+nuxt+webpack）介绍
zouyang920的博客
03-08 3208
1.项目结构 2.目录和代码分析 build的文件夹：主要放置webpack的打包文件的，webpack自动生成不用管。 config目录，用于配置请求地址前缀的。 peod.env.js： 'use strict' module.exports = { NODE_ENV: '"production"', BASE_API: '"https://easy-mock.com/mock/5950a2419adc231f356a6636/vue-admin"', } dev.env.js：
SpringContextHolder获取bean的工具类
zouyang920的博客
03-18 208
/* * Copyright (c) 2020 pig4cloud Authors. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *
java8的LocalDateTime还没搞懂？一文轻松解决掉你的烦恼
重燃小窗
08-02 194
java都出到17了，我这java8的LocalDateTIme都没怎么研究过。感觉是有点说不过去啊，周末的时候在家把源码看了看，写了一个工具类，以便将来的开发过程中省时省力。这段时间换工作，新的公司用java8语法糖用的很多，上周开发一个需求，用到时间计算，因为这个时间计算，搞了两个小时。......
BST.rar_bst
09-20
BST数据结构问题的c++代码实现，自己写的，希望对大家有帮助
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 358
unordered_map实现输出前k个高频元素
回溯之分割回文串
JINbigXIA的博客
06-04 177
思路：直接看回溯函数的内容，首先我们是取段的，如果这一段不行那就往后面加1，直到加道循环结束。如果可以取端，并且取到了最后一段，也就是开始的startIndex大于等于size那么就代表这一条都是回文字符串。然后需要一个判断函数，判断字符串是否为回文字符串，如果是往path里面加。学到的新函数：array.substr( a ,b) a表示字符串的开始，b表示数量 含义：选取字符串array从a开始往后的b个数。难点：这里用到一个很取段的思路，其实和取点的内容差不多，但是取端更难理解。
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
2201_75456895的博客
05-30 1231
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
算法-找出N个数组的共同元素
Python领域优质萌新创作者
06-02 451
3.1、使用集合的intersection_update方法，将当前编辑的新闻编号集合与common_news_set取交集，并更新common_news_set。1.1、使用集合的交集操作找出被所有编辑共同编辑过的新闻：遍历每个新闻集合进行交集操作，时间复杂度为O(K)，其中K为所有编辑操作的总数。3.2、这样，common_news_set中将保留与当前编辑共同编辑过的新闻编号，即找到所有编辑共同编辑过的新闻编号的交集。news_ids: 一个包含N个列表的列表，每个列表包含一个编辑编辑过的新闻编号。
c++ - 模板(二)
最新发布
2302_79539362的博客
06-05 822
TYPE是类型按道理来说没有问题，但是编译器在检查到这里是就会出现歧义，不知道TYPE是类型还是静态变量，所以就会报错。给模板初始值与给函数初始值类似，当需要给一部分缺省值时，参数缺省值必须从右向左给，中间不能留着参数不给缺省值。非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。另一种解决方法就是直接写一个该类型的函数，这个函数会与模板函数构成重载，并且符合的话会被优先使用。在没有被实例化时，编译器只会对函数进行语法等检查，不会查看类内部细节，如上面的。
二叉树的统一迭代法-前序中序后序-力扣
why_12134的博客
06-05 125
通过对入栈的节点进行标记，只有当标记出现时，才将该元素添加到输出数组中，否则就继续遍历下去。通过更改标记节点 和左右节点的入栈顺序，从而达到只需修改代码顺序，就能切换功能，实现代码统一的目的。之前写的二叉树的前中后序遍历的迭代方法，中序遍历与前序后序遍历的代码并不统一，无法像递归那样只是修改顺序，就可以完成，在看完代码随想录二叉树的统一迭代法的章节后，记录一下。，可以发现，使用NULL来标记需要处理的节点，在遍历时，只需更改左右节点和中间节点的入栈顺序，就能实现不同的遍历顺序。
bst python
08-20
BST（Binary Search Tree）是一种常见的搜索数据结构，它具有以下特点： - 每个节点最多有两个子节点：左子节点和右子节点。 - 左子节点的值小于等于父节点的值，右子节点的值大于父节点的值。 - 对于每个节点，其左子树和右子树都是二叉搜索树。 以下是一个用Python实现的BST示例： ```python class Node: def __init__(self, value): self.value = value self.left = None self.right = None class BST: def __init__(self): self.root = None def insert(self, value): if self.root is None: self.root = Node(value) else: self._insert_recursive(self.root, value) def _insert_recursive(self, node, value): if value < node.value: if node.left is None: node.left = Node(value) else: self._insert_recursive(node.left, value) else: if node.right is None: node.right = Node(value) else: self._insert_recursive(node.right, value) def search(self, value): return self._search_recursive(self.root, value) def _search_recursive(self, node, value): if node is None or node.value == value: return node elif value < node.value: return self._search_recursive(node.left, value) else: return self._search_recursive(node.right, value) ``` 你可以使用该BST类来创建一个二叉搜索树，并进行插入和搜索操作。例如： ```python bst = BST() bst.insert(5) bst.insert(3) bst.insert(7) bst.insert(1) bst.insert(4) print(bst.search(3)) # 输出: <__main__.Node object at 0x...> ``` 希望以上代码能帮到你！如果有任何疑问，请随时问我。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值