二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 1: 输入: 2 / \ 1 3 输出: true 示例 2: 输入: 5 / \ 1 4 / \ 3 6 输出: false 解释: 输入为: [5,1,4,null,null,3,6]。 根节点的值为 5 ，但是其右子节点值为 4 。 1 /** 2 * Definition for a binary tree node. 3 * struct TreeNode { 4 * int val; 5 * TreeNode *left; 6 * TreeNode *right; 7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 * }; 9 */ 10 class Solution { 11 long last = LONG_MIN; 12 public: 13 bool isValidBST(TreeNode* root) { 14 if(root==nullptr) 15 { 16 return true; 17 } 18 19 //比左树 20 if(!isValidBST(root->left))

给定一个二叉搜索树，同时给定最小边界L 和最大边界 R。通过修剪二叉搜索树，使得所有节点的值在[L, R]中 (R>=L) 。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。 solution： 1 /** 2 * Definition for a binary tree node. 3 * struct TreeNode { 4 * int val; 5 * TreeNode *left; 6 * TreeNode *right; 7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 * }; 9 */ 10 class Solution { 11 public: 12 TreeNode* trimBST(TreeNode* root, int L, int R) { 13 if(root == nullptr) return root; 14 if(root->val > R) return trimBST(root->left,L,R); 15 if(root->val < L) return trimBST(root->right,L,R); 16 root->left = trimBST(root->left,L,R); 17 root->right = trimBST(root-

98. 验证二叉搜索树 https://leetcode-cn.com/problems/validate-binary-search-tree/ 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 解： 中序遍历二叉排序树，判断得到的数组是否是升序。 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: def isValidBST(self, root: TreeNode) -> bool: inorder = self.inorder(root) return inorder == sorted(set(inorder)) # 这里要注意判重 def inorder(self, root): if root is None: return [] return self.inorder(root.left) + [root.val] + self.inorder(root.right)

【问题】输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 【思路】注意题目给出的是二叉搜索树，那么它就有一个很重要的性质： 左孩子值<=根的值<=右孩子的值！ 但题目中说明了任意两个数字都互不相同，说明没有重复数字。 由于给出的是后序遍历，我们就可以知道最后一个数为根节点，并且其左子树的值均小于根节点的值，右子树的值均大于根节点的值。因此我们可以从头遍历，直到找到第一个大于根节点的值，我们就可以得到左右子树划分的边界，其后面所有值都应该大于根节点的值，最后利用分治思想进行递归即可！ class Solution { public: bool process(vector<int> seq, int start, int end){ if(seq.size() == 0) return false; int i; // 左子树的索引 if (start >= end){ return true; } for(i = 0;i < end; i++){ if(seq[i] > seq[end]){ break; } } for(int j = i;j < end; j++){ // j 为右子树的索引 if(seq[j] < seq[end]){ return false; } } return

BinTree Insert( BinTree BST, ElementType X ) { if ( !BST ){ /* 若原树为空，生成并返回一个结点的二叉搜索树 */ BST = (BinTree) malloc ( sizeof ( struct TNode)); BST->Data = X; BST->Left = BST->Right = NULL; } else { /* 开始找要插入元素的位置 */ if ( X < BST->Data ) BST->Left = Insert( BST->Left, X ); /*递归插入左子树*/ else if ( X > BST->Data ) BST->Right = Insert( BST->Right, X ); /*递归插入右子树*/ /* else X已经存在，什么都不做 */ } return BST; } BinTree Delete( BinTree BST, ElementType X ) { Position Tmp; if ( !BST ) printf ( "要删除的元素未找到" ); else { if ( X < BST->Data ) BST->Left = Delete( BST->Left, X ); /* 从左子树递归删除 */ else if ( X > BST->Data ) BST

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 方法一：非递归版 //解题思路： //1.核心是中序遍历的非递归算法。 //2.修改当前遍历节点与前一遍历节点的指针指向。 import java.util.Stack; public TreeNode ConvertBSTToBiList(TreeNode root) { if(root==null) return null; Stack<TreeNode> stack = new Stack<TreeNode>(); TreeNode p = root; TreeNode pre = null;// 用于保存中序遍历序列的上一节点 boolean isFirst = true; while(p!=null||!stack.isEmpty()){ while(p!=null){ stack.push(p); p = p.left; } p = stack.pop(); if(isFirst){ root = p;// 将中序遍历序列中的第一个节点记为root pre = root; isFirst = false; }else{ pre.right = p; p.left = pre; pre = p; } p = p.right; } return root; }

题目描述： 给定一个整数 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 思路分析： 树的题目，首先就是用递归思想来做。自己一开始的做法，是不停的去拷贝对象，这样容易出错，且很繁琐。参考了别人的代码，直接用指针简洁了很多。 代码： 1 /** 2 * Definition for a binary tree node. 3 * struct TreeNode { 4 * int val; 5 * TreeNode *left; 6 * TreeNode *right; 7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 * }; 9 */ 10 class Solution { 11 public: 12 vector<TreeNode*> generateTreesCore(int l, int r) 13 { 14 vector<TreeNode*>ans; 15 if

给定一个二叉搜索树的根结点 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的差值。 注意： 二叉树的大小范围在 2 到 100。 二叉树总是有效的，每个节点的值都是整数，且不重复。 来源：力扣（LeetCode） 链接： https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 解题思路 1.根据二叉搜索树的性质，中序遍历二叉搜索树可以得到一个结点值递增的序列，然后在遍历的过程中存储这个序列，再用循环遍历这个序列求相邻元素间的最小差值。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x

题目要求： 分析： 首先看看什么叫二叉搜索树。百度百科是这样定义的： 所以左子树的所有值都比根节点要小，右子树的所有值都比根节点要大。 这里要求1,2,…,n的二叉搜索树有多少种，我们这样来考虑： 假设在1,2,…,n中，我们取第nums[i]个作为根节点，那么i个数（1 ~ i - 1，再加上一个空树的情况）全都比nums[i]要小，后面n - i - 1个数全都比nums[i]要大； 而查找不同形态的二叉搜索树的个数是满足Catalan数的，这个是数学上的一个式子，不去深究，但是 二叉搜索树的个数 = 左子树的个数 * 右子树的个数 （可以理解为左边所有情况 * 右边所有情况）； 那么根据二叉搜索树的要求，作为左子树的值肯定要比根节点的值要小，从nums[1] ~ nums[i - 1]对这些值进行遍历，让它们挨个作为左子树，其它的都作为右子树，然后将它们的值相乘就好了。 **注：**这里的nums的范围是nums[0] ~ nums[n]，因为也要判断没有数字的情况，此时为nums[0]，是一颗空树，所以可以认为只有一种排序方法，返回1. 举个 例子 可能比较好理解： 具体代码如下： class Solution { public int numTrees(int n) { if(n == 0) return 0; if(n == 1) return 1; int[]

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。 说明： 你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。 示例 1: 输入: root = [3,1,4,null,2], k = 1 3 / \ 1 4 \ 2 输出: 1 示例 2: 输入: root = [5,3,6,2,4,null,null,1], k = 3 5 / \ 3 6 / \ 2 4 / 1 输出: 3 进阶： 如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 k 小的值，你将如何优化 kthSmallest 函数？ /** * 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: int kthSmallest(TreeNode* root, int k) { int cnt = 0; stack<TreeNode*> s; TreeNode *p = root; while (p || !s.empty()) {