二叉搜索树

在数据结构中，二叉树是一种比较常见的树结构。在有的应用场景下，为什么要使用二查搜索树呢？使用二查搜索树可以给我们带来什么好处呢？ 比如我们做查询操作时，数组的查询插入或者删除的最坏的时间复杂度是O(n) 当我们把这个数组进行排序以后，查询的最坏时间复杂度为o(log n),但是插入和删除元素的时间复杂度依然没有发生变化。 二叉搜素树的查询插入和删除的最坏时间复杂度都为o(log n)，所以使用二叉搜索树可以大大的提高效率。 二叉搜索树服从以下的规则： 任意一个节点的值都大于左子树节点的值 任意一个节点的值都小于右子树节点的值 每个节点的左右子树依然是一颗二叉搜索树 package com.BinarySearchTree; import java.util.ArrayList; public class BinarySearchTree { public static void main(String[] args) { BinarySearchTree binarySearchTree = new BinarySearchTree(); binarySearchTree.add(7); binarySearchTree.add(4); binarySearchTree.add(9); binarySearchTree.add(2); binarySearchTree.add(5)

给定一个整数 n，生成所有由 1 ... n 为节点所组成的二叉搜索树。 示例: 输入: 3 输出: [ [1,null,3,2], [3,2,null,1], [3,1,null,null,2], [2,1,3], [1,null,2,null,3] ] 解释: 以上的输出对应以下 5 种不同结构的二叉搜索树： 1 3 3 2 1 \ / / / \ \ 3 2 1 1 3 2 / / \ \ 2 1 2 3 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/unique-binary-search-trees-ii 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: vector<TreeNode*> generateTrees(int n) { if (n == 0) return {}; return helper

1. 题目描述 /* 给定一棵二叉搜索树，请找出其中的第k小的结点。 例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。 */ 2. 思路 中序遍历二叉搜索树，第K个就是结果 3. 非递归 import java.util.*; public class Solution { static TreeNode KthNode(TreeNode pRoot, int k){ return inorderNR(pRoot, k); } public static TreeNode inorderNR(TreeNode pRoot, int k){ int count = 0; Stack<TreeNode> s = new Stack<>(); TreeNode curr = pRoot; while(curr != null || !s.empty()){ while(curr != null){ s.push(curr); curr = curr.left; } curr = s.pop(); count++; if(count == k){ break; } curr = curr.right; } return curr; } } 4. 递归 import java.util.*; public class Solution { TreeNode

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 public class Solution { private TreeNode pre = null; //上一个节点 private TreeNode head = null; //当前节点 public TreeNode Convert(TreeNode root) { inOrder(root); return head; } private void inOrder(TreeNode node) { //输入一个 node if (node == null) //判空 return; inOrder(node.left); // 左孩子递归 node.left = pre; // 上个节点赋值给 left if (pre != null) //如果上个节点不为空 pre.right = node; //node 给 pre = node; if (head == null) head = node; inOrder(node.right); } } 解题思路： 1.核心是中序遍历的非递归算法。 2.修改当前遍历节点与前一遍历节点的指针指向。 import java.util.Stack; public TreeNode ConvertBSTToBiList

题目描述： 给定一个二叉搜索树，编写一个函数kthSmallest来查找其中第k个最小的元素。 说明： 你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。 知识点： 二叉树中序遍历 思路和代码： 使用二叉树中序遍历的方法，找到第k小的数直接退出 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution : def kthSmallest ( self , root : TreeNode , k : int ) - > int : temp_stack = [ ] # 存储栈 min_v = 0 while root or temp_stack : while root : temp_stack . append ( root ) root = root . left root = temp_stack . pop ( ) min_v = root . val k -= 1 if k == 0 : break root = root . right return min_v 来源： https://blog.csdn.net

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。假设输入的数组的任意两个数字都互不相同。 例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。 使用递归的方式，先判断数组的左子树和右子树的位置 然后再判断左子树和右子树是不是二叉搜索树。 public boolean VerifySquenceOfBST(int[] sequence) { if (sequence == null || sequence.length == 0) return false; return verify(sequence, 0, sequence.length - 1); } private boolean verify(int[] sequence, int first, int last) { if (last - first <= 1) return true; int rootVal = sequence[last]; int cutIndex = first; while (cutIndex < last && sequence[cutIndex] <= rootVal) cutIndex++; for (int i = cutIndex; i < last; i++) if (sequence[i] < rootVal) return false; return

1 题目 链接： 二叉搜索树结点最小距离 给定一个二叉搜索树的根结点 root, 返回树中任意两节点的差的最小值。 示例： 输入: root = [4,2,6,1,3,null,null] 输出: 1 解释: 注意，root是树结点对象(TreeNode object)，而不是数组。 给定的树 [4,2,6,1,3,null,null] 可表示为下图: 4 / \ 2 6 / \ 1 3 最小的差值是 1, 它是节点1和节点2的差值, 也是节点3和节点2的差值。 注意： 1、二叉树的大小范围在 2 到 100。 2、二叉树总是有效的，每个节点的值都是整数，且不重复。 2 Python # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution : def minDiffInBST ( self , root : TreeNode ) - > int : ans = 99 # 注意不能初始化为ans = int def inorderTraversal ( root ) : ans = [ ] if not root : return ans

1.和课本思路保持一致，先找到了根节点 因为是二叉搜索树 所以比根节点值小的是左子树，比根节点大的是右子树 判断完一轮后 将左子树放进去再进行判断！ 右子树进行判断 ；当然考虑什么时候有左右子树； class Solution { public: bool VerifySquenceOfBST(vector<int> sequence) { if(sequence.empty()) return false; int length=sequence.size(); int root=sequence.at(length-1);//最后一个 int i=0; vector<int> left; vector<int> right; //找出左子树 值都小于根节点的值 for(i=0;i<length-1;i++) { if(sequence[i]>root) break; //退出循环 得知i left.push_back(sequence[i]); } //找出右子树 值都大于根节点的值 for(int j=i;j<length-1;j++) { if(sequence[j]<root) //后面有比根节点小的 直接报错 return false; right.push_back(sequence[j]); } bool leftflag=true; //如果没有 就是成功

二叉查找树（Binary Search Tree），或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 转载于:https://www.cnblogs.com/FCWORLD/archive/2011/03/14/1984181.html 来源： https://blog.csdn.net/weixin_30379531/article/details/99910124

题目描述 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 1 /* 2 struct TreeNode { 3 int val; 4 struct TreeNode *left; 5 struct TreeNode *right; 6 TreeNode(int x) : 7 val(x), left(NULL), right(NULL) { 8 } 9 };*/ 10 class Solution { 11 public: 12 TreeNode* Convert(TreeNode* pRootOfTree) 13 { 14 TreeNode *pLastNodeInTree = NULL; 15 TreeConvert(pRootOfTree, pLastNodeInTree); 16 TreeNode *pFirstNodeInTree = pLastNodeInTree; 17 while (pFirstNodeInTree != NULL && pFirstNodeInTree->left != NULL) { 18 pFirstNodeInTree = pFirstNodeInTree->left; 19 } 20 return pFirstNodeInTree; 21 } 22 void