首先我们先来复习一下二分查找的算法 对于正向序列的二分查找
递归实现：
1 bool binary_search(vector<int> &sort_arry,int begin,int end,int target) 2 { 3 if(begin>end) 4 return false; 5 int mid = (begin + end) / 2; 6 if(sort_arry[mid] == target) 7 return true; 8 else if(sort_arry[mid] > target) 9 { 10 return binary_search(sort_arry,begin,mid-1,target); 11 } 12 else 13 { 14 return binary_search(sort_arry,mid+1,end,target); 15 } 16 }
循环实现：
1 bool binary_search(vector<int> &sort_arry,int target) 2 { 3 int begin = 0; 4 int end = sort_arry.size() - 1; 5 int mid = (begin + end) / 2; 6 while(begin <= end) 7 { 8 if(sort_arry[mid] == target) 9 return true; 10 else if(sort_arry[mid] > target) 11 { 12 end = mid - 1; 13 } 14 else 15 { 16 begin = mid + 1; 17 } 18 mid = (begin + end) / 2; 19 } 20 return false; 21 }
35. 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0
输出: 0
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-insert-position
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution { public: int searchInsert(vector<int>& nums, int target) { int index = -1; int begin =0; int end = nums.size(); while(index == -1) { int mid = (begin + end) / 2; if(target == nums[mid]) index =mid; else if(target < nums[mid]) { if(mid ==0 ||target > nums[mid-1]) index = mid; end = mid - 1; } else if(target > nums[mid]) { if(mid == nums.size()-1 || target < nums[mid+1]) return mid + 1; begin = mid + 1; } } return index; } };
34. 在排序数组中查找元素的第一个和最后一个位置
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
你的算法时间复杂度必须是 O(log n) 级别。
如果数组中不存在目标值，返回 [-1, -1]。
示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
int left_bond(vector<int> &nums,int target) { int begin; int end = nums.size()-1; while(begin <= end) { int mid = (begin + end)/2; if(target == nums[mid]) { if(mid == 0 || nums[mid-1] < target) { return mid; } end = mid - 1; } else if(target < nums[mid]) { end = mid - 1; } else { begin = mid + 1; } } return -1; } int right_bond(vector<int> &nums,int target) { int begin; int end = nums.size()-1; while(begin <= end) { int mid = (begin + end)/2; if(target == nums[mid]) { if(mid == nums.size()-1 || nums[mid + 1] > target) { return mid; } begin = mid + 1; } else if(target < nums[mid]) { end = mid - 1; } else { begin = mid + 1; } } return -1; } class Solution { public: vector<int> searchRange(vector<int>& nums, int target) { vector<int> result; result.push_back(left_bond(nums,target)); result.push_back(right_bond(nums,target)); return result; } };
旋转数组：
33. 搜索旋转排序数组
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
分析：
·如果target < nums[mid]的情况：
1：如果nums[begin] < nums[end]:
有两种可能 要么没转过 要么 转过（nums[begin] >nums[end]）
说明此时递增区间为begin~mid-1 旋转区间为mid+1~end
比如是[7 9 12 15 20 1 3 6]的target =12
因为12 >begin 所以就在递增区间找
否则如果target = 3 < begin 应该在旋转区间中查找
2：如果begin > mid 说明旋转区间在begin到mid-1之间，递增区间在mid+1到end之间
比如[20 1 3 6 7 8 12 15]
target = 3 （< mid） 说明递增区间已经不可能了，直接在旋转区间begin到mid-1中查找
3：如果begin == mid 说明目标只能在mid+1到end之间查找 比如target = 1的时候数组是[6,1]
·如果目标target > nums[mid]的情况：
1:当nums[begin] < nums[mid],说明递增区间是[begin,mid-1]旋转区间为[mid+1,end]
比如数组[7 9 12 15 20 1 3 6]
递增区间7~15旋转区间在20~6
因为target已经大于mid处的值了，因此直接在旋转区间查找。
例如查找target=20就在20~6里面找
2：如果是nums[begin] > nums[mid]的情况 (有可能存在begin>end)
说明递增区间在后半部分mid+1~end旋转区间在前半部分begin~mid-1
比如15 20 1 3 6 7 9 12
如果target=20>begin 那就在旋转区间begin~mid-1里找 ，否则在递增区间mid+1~end里找
3：如果是begin == mid的情况那么也只可能在mid+1~end之间
比如target = 7 数组是[6 7]
class Solution { public: int search(vector<int>& nums, int target) { int begin =0; int end = nums.size() - 1; if(nums.size()==1) { if(nums[0]==target) return 0; else return -1; } while(begin <= end)//递增区间在前半部分 { int mid = (begin + end) / 2; if(target == nums[mid]) { return mid; } else if(target < nums[mid]) { if(nums[begin] < nums[mid]) { if(target >= nums[begin])//说明应递增区间为begin~mid-1之间 旋转区间为mid+1~end之间 { end = mid -1; } else { begin = mid + 1; } } else if(nums[begin] > nums[mid])//说明递增区间在后面mid+1~end { end = mid -1; } else if(nums[begin] == nums[mid])//说明目标只可能在mid+1~end之间 { begin = mid + 1; } } else if(target > nums[mid]) { if(nums[begin] < nums[mid])//说明递增区间是begin~mid-1，旋转区间在后半部分 { begin = mid + 1; } else if(nums[begin] > nums[mid]) { if(target >= nums[begin])//说明递增区间在mid+1到end 旋转区间在前半部分。 { end = mid - 1; } else { begin = mid + 1; } } else if(nums[begin] == nums[mid])//说明只能在mid+1~end之间 { begin = mid + 1; } } } return -1; } };
这题的边界真的很恶心…
接下来介绍一个数据结构 二叉查找树
二叉查找树是具有以下性质的二叉树：
1：若左子树不为空，则左子树上所有节点的值均小于或等于他的根节点
2：若右子树不为空，则右子树上所有节点的值均大于或等于他的根节点
3：二叉查找树的左右子树也是二叉查找树
4：等于的情况只能出现在左子树或右子树的某一侧（不能同时出现）
由于二叉查找树的中序遍历是从小到大的，所以称之为二叉查找树。
二叉查找树的插入操作：
if insert_node节点的值小于当前node的节点值
{
if (node有左子树) 则递归的将该节点插入到左子树为根的二叉排序树中，
else (将node的left赋值为该节点的地址
}
else//（大于等于的情况下）
{
if（node有右子树）则递归的将该节点插入到右子树为根的二叉排序树中
else （将node->right赋值为该节点的地址）
}
void BST_insert(TreeNode *node,TreeNode *insert_node) { if(insert_node->val< node->val) { if(node->left) { BST_insert(node->left,insert_node); } else { node->left = insert_node; } } else { if(node->right) { BST_insert(node->right,insert_node); } else { node->right = insert_node; } } }
二叉树的查找：
查找数组val是否在二叉树中出现：
如果val == 当前节点的值返回真，
如果val < 当前节点的值
{
如果当前节点有左子树，继续左子树中查找该值，否则返回false；
否则{
如果当前节点有右子树，就继续在右子树中查找，否则返回false;
}
}
void BST_search(TreeNode*node,int val) { if(node->val == val) return true; if(val < node->val) { if(node->left) { BST_search(node,val); } else { return false; } } else { if(node->right) { BST_search(node,val); } else { return false; } } }
449. 序列化和反序列化二叉搜索树
序列化是将数据结构或对象转换为一系列位的过程，以便它可以存储在文件或内存缓冲区中，或通过网络连接链路传输，以便稍后在同一个或另一个计算机环境中重建。
设计一个算法来序列化和反序列化二叉搜索树。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串，并且可以将该字符串反序列化为最初的二叉搜索树。
编码的字符串应尽可能紧凑。
注意：不要使用类成员/全局/静态变量来存储状态。 你的序列化和反序列化算法应该是无状态的。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/serialize-and-deserialize-bst
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Codec { public: void BST_insert(TreeNode *node,TreeNode *insert_node) { if(insert_node->val< node->val) { if(node->left) { BST_insert(node->left,insert_node); } else { node->left = insert_node; } } else { if(node->right) { BST_insert(node->right,insert_node); } else { node->right = insert_node; } } } bool BST_search(TreeNode*node,int val) { if(node->val == val) return true; if(val < node->val) { if(node->left) { BST_search(node,val); } else { return false; } } else { if(node->right) { BST_search(node,val); } else { return false; } } } void change_int_to_str(int val, string &str) { string temp; while(val) { temp += (val % 10) +'0'; val = val / 10; } for(int i = temp.length() - 1;i >= 0;i--)//逆序将字符串插入到str中 { str += temp[i]; } str += '#';//转换完以后用#分割 } void BST_preorder(TreeNode *node,string &data) { if(!node) { return; } string str;//前序遍历把每次val添加到str中。 change_int_to_str(node->val,str); data += str;//每次转换就添加，然后继续递归遍历 BST_preorder(node->left,data); BST_preorder(node->right,data); } // Encodes a tree to a single string. string serialize(TreeNode* root) { string data; BST_preorder(root,data); return data; } // Decodes your encoded data to tree. TreeNode* deserialize(string data) { if(data.length() == 0) { return NULL; } vector<TreeNode*>node_vec; int val = 0; for(int i = 0; i < data.length();i++) { if(data[i] == '#') { node_vec.push_back(new TreeNode(val)); val = 0; } else { val = val *10 + data[i] - '0'; } } for(int i = 1;i < node_vec.size();i++) { BST_insert(node_vec[0],node_vec[i]); } return node_vec[0]; } }; // Your Codec object will be instantiated and called as such: // Codec codec; // codec.deserialize(codec.serialize(root));
315. 计算右侧小于当前元素的个数
给定一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。
示例:
输入: [5,2,6,1]
输出: [2,1,1,0]
解释:
5 的右侧有 2 个更小的元素 (2 和 1).
2 的右侧仅有 1 个更小的元素 (1).
6 的右侧有 1 个更小的元素 (1).
1 的右侧有 0 个更小的元素.
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-of-smaller-numbers-after-self
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路分析：
将元素安装原数组逆置后的顺序插入到二叉查找树中，设置变量count_small = 0记录在插入过程中，有多少个元素比插入节点值小，
若待插入的节点值<=node->val，那么node->count++，并且递归的将该节点插入到当前节点的左子树。
若当待插入节点值大于当前节点的node的值，count_small+=node->count+1（当前节点左子树量+1）
递归将该节点插入到当前节点的右子树。
struct BSTNode { int val; int icount; BSTNode* left; BSTNode* right; BSTNode(int val) { val = val; left = NULL; right = NULL; icount = 0; } }; class Solution { public: void BST_insert(BSTNode *node,BSTNode *insert_node,int &count_small) { if(insert_node->val <= node->val) { node->icount++; if(node->left) { BST_insert(node->left,insert_node,count_small); } else { node->left = insert_node; } } else { count_small += node->icount + 1; if(node->right) { BST_insert(node->right,insert_node,count_small); } else { node->right = insert_node; } } } vector<int> countSmaller(vector<int>& nums) { vector <int> result;//最终逆序数组 vector<BSTNode*> node_vec;//创建二叉查找树节点池 vector<int> icount;//从后插入过程中比当前节点小的count_small数组。 for(int i = nums.size() - 1;i >= 0;i--) { node_vec.push_back(new BSTNode(nums[i])); } icount.push_back(0);//第一个节点count_small = 0 for(int i = 1; i < node_vec.size(); i++) { int count_small = 0; BST_insert(node_vec[0],node_vec[i],count_small); icount.push_back(count_small); } for(int i = node_vec.size() - 1; i >= 0; i--)//将countsmall倒push到result数组中 { delete node_vec[i]; result.push_back(icount[i]); } return result; } };