二分查找与二叉查找树
例1：二分查找
已知一个 排序数组 A，如 A = [-1, 2, 5, 20, 90, 100, 207, 800]，另外一个 乱序数组 B，如 B = [50, 90, 3, -1, 207, 80]，
求B中的任意某个元素，是否在A中出现， 结果 存储在数组C中， 出现用1 代表， 未出现用0 代表，如，C = [0, 1, 0, 1, 1, 0]。
**分析：**二分查找 又称 折半查找 ，首先，假设表中元素是按 升序排列 ，将表 中间位置 的关键字与查找关键字比较：
1.如果两者 相等 ，则 查找成功 ；
2.否则利用 中间位置 将表分成 前、后 两个子表：
1)如果中间位置的关键字 大于 查找关键字，则进一步查找 前一子表
2)否则进一步查找 后一子表
重复以上过程， 直到 找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
例如对于待搜索数字target==2,200，数组A=[-1,2,5,20,90,100,207,800]
示例代码：
/*基于递归思路*/
bool binary_search(vector<int>&sort_array, int begin, int end, int target) {
if (end < begin) {
return false;
}
int mid = (begin + end) / 2;
if (target == sort_array[mid]) {
return true;
}
else if(target<sort_array[mid])
{
return binary_search(sort_array, begin, mid - 1, target);
}
else if (target > sort_array[mid]) {
return binary_search(sort_array, begin + 1, mid, target);
}
}
/*基于循环思路*/
bool binary_search(vector<int>&sort_array, int target) {
int begin = 0;
int end = sort_array.size() - 1;
while (begin<=end)
{
int mid = (begin + end) / 2;
if (target == sort_array[mid]) {
return true;
}
else if (target < sort_array[mid]) {
end = mid - 1;
}
else if(target>sort_array[mid])
{
begin = mid + 1;
}
}
return false;
}
例2：插入位置
给定一个 排序数组nums( 无重复元素加粗样式) 与 目标值target ，如果target在nums里出现 ，则返回 target 所在下标 ，如果target在nums里 未出现 ，则返回target 应该插入位置 的数组下标，使得将target插入数组nums后，数组仍 有序 。
分析：
1.当target在nums中 出现 时，二分查找的流程无变化。
2.当target在nums 没有出现 时:
1)如果 target < nums[mid]，且target > nums[mid - 1] ；
说明了 什么？
2)如果 target > nums[mid]，且target < nums[mid + 1]；
说明了 什么？
3.当mid == 0 或者mid == nums.size() – 1时，这样的 边界条件 ，应该如何处理？
设元素 所在的位置 (或最终需要 插入的位置 )为index，
在二分查找的 过程 中:
①如果target == nums[mid]：index = mid；
②如果target < nums[mid]，且 (mid == 0或 target > nums[mid-1])：
index = mid；
③如果target > nums[mid]，且 (mid == nums.size() – 1 或 target < nums[mid+1])：
index = mid + 1；
例如：
那么，待插入的元素2此时的下标就是1，待插入的元素4的下标就是2.
示例代码：
class Solution {
public:
int searchInsert(vector<int>&nums,int target) {
int index = -1;
int begin = 0;
int end = nums.size()-1;
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]) {//注意，这里的mid必须等于nums.size()-1，而不能等于end
index = mid + 1;
}
begin = mid + 1;
}
}
return index;
}
};
例3：区间查找
给定一个 排序数组nums (nums中有 重复 元素)与 目标值target ，如果target在nums里 出现 ，则返回target所在区间的 左右端点下标 ，[左端点,右端点]，如果target在nums里 未出现 ，则返回[-1, -1]。
分析：
对于查找区间，方法一就是可以直接使用二分查找找到对应的元素，在找到相应的左右端点。
方法二就是直接找对应的左右端点。
查找区间 左端点 时，增加如下 限制条件 :
当target == nums[mid]时，若此时mid == 0或nums[mid-1] < target，则说明mid即为区间左端点，返回；否则设置查找区间右端点为mid-1。
查找区间 右端点 时，增加如下 限制条件 :
当target == nums[mid]时，若此时mid == nums.size() – 1或 nums[mid + 1] >target，则说明mid即为区间右端点；否则设置区间左端点为mid + 1
示例代码;
class Solution {
public:
/*区间左端点*/
int left_bound(vector<int>& nums, int target) {
int begin = 0;
int end = nums.size() - 1;
while (begin<=end)
{
int mid = (begin + end) / 2;
if (target == nums[mid]) {
if (mid == 0 || target > nums[mid - 1]) {
return mid;
}
end = mid - 1;
}
else if(target<nums[mid])
{
end = mid - 1;
}
else if(target>nums[mid])
{
begin = mid + 1;
}
}
return -1;
}
/*区间右端点*/
int right_bound(vector<int>&nums, int target) {
int begin = 0;
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;
}
else if(target<nums[mid])
{
end = mid - 1;
}
else if(target>nums[mid])
{
begin = mid + 1;
}
}
}
return -1;
}
};
例4：旋转数组查找
给定一个 排序数组nums (nums中 无重复 元素)，且nums可能以 某个未知 下标旋转 ，给定 目标值target ，求target是否在nums中出现，若出现返回所在下标 ，未出现返回-1。
分析：
在 旋转数组 [7, 9, 12, 15, 20, 1, 3, 6]中，若 硬使用 未加修改的 二分查找，查找target = 12 或target = 3，会 出现 什么情况？
当前mid = 3，nums[mid] = 15:
查找target = 12 :target(12) < numsmid，则在子区间[7, 9, 12]中继续查找，可找到12，返回 正确 结果。
查找target = 3 :target(3) < numsmid，则在子区间[7, 9, 12]中继续查找，不可找到3，返回错误 结果。
思考：
二分查找是否还可以 继续使用 ，若希望获得正确的结果，应 如何修改 ？
修改如下：旋转数组 :[7, 9, 12, 15, 20, 1, 3, 6], nums[begin]>nums[end]
查找target = 12 时:由于target(12) < numsmid， 查找正确 的原因:
1.numsbegin < numsmid，区间[7, 9, 12, 15] 顺序递增 ，
2.target(12) > numsbegin，故target(12)只可能在顺序递增区间[7, 9, 12, 15]中。
在查找target = 3 时:由于target(3) < numsmid， 查找错误 的原因:
1.numsbegin < numsmid，区间[20, 1, 3, 6]包括 旋转 点，为 旋转区间 ，
2.target(3) < numsbegin，故target(3)可能在旋转区间[20, 1, 3, 6]中，此时忽略了该情况。
结论：
若希望使用二分查找，需要修改二分查找，将 可能在旋转区间 [20, 1, 3, 6]的情况考虑进去。
分类讨论：
情况一：
情况二：
示例代码：
class Solution {
public:
int search(vector<int>&nums, int target) {
int begin = 0;
int end = nums.size() - 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]) {//隐含着nums[begin]>nums[end]
if (target>nums[begin])
{
end = mid - 1;
}
else
{
begin = mid + 1;
}
}
else if(nums[begin]>nums[mid])
{
end = mid - 1;
}
else if (nums[begin] == nums[mid]) {
begin = mid + 1;
}
}
else if(target>nums[mid])
{
if (nums[begin] > nums[mid]) {
begin = mid + 1;
}
else if (nums[begin] < nums[mid]) {
if (target >= nums[begin]) {
end = mid - 1;
}
else
{
begin = mid + 1;
}
}
else if(nums[begin]==nums[mid])
{
begin = mid + 1;
}
}
}
return -1;
}
};
二叉查找树 (Binary Search Tree), 它是一颗具有下列性质的 二叉树 :
1.若 左子树 不空，则左子树上 所有结点 的值均 小于或等于 它的 根结点 的值；
2.若 右子树 不空，则右子树上 所有结点 的值均 大于或等于 它的 根结点 的值；
3.左、右子树也分别为 二叉排序树 。
4.等于 的情况 只能出现在 左子树或右子树中的 某一侧 。
例5：二叉查找树插入节点
将 某节点(insert_node) ，插入至 以 以node 为根 二叉查找树中:
如果 insert_node节点值 小于 当前node节点值:
如果node 有左子树 ，则 递归 的将该节点插入至左子树为根二叉排序树中
否则，将 node->left 赋值 为该节点地址
否则( 大于等于 情况):
如果node 有右子树 ，则递归的将该节点插入至右子树为根二叉排序树中
否则，将 node->right 赋值 为该节点地址
示例代码:
void BST_insert(TreeNode*node, TreeNode*insert_node) {
if (insert_node->val < node->val) {
if (node->left) {//当左子树不为空的时候，递归的将insert_node插入左子树
BST_insert(node->left, insert_node);
}
else {//当左子树为空的时候，将node的左指针与待插入节点相连接
node->left = insert_node;
}
}
else
{
if (node->right) {//当右子树不为空的时候，递归的将insert_node插入右子树
BST_insert(node->right, insert_node);
}
else {//当右子树为空的时候，将node的右指针与待插入节点相连接
node->right = insert_node;
}
}
}
例6：二叉查找树查找数值
查找 数值value 是否 在 二叉查找树 中 出现 :
如果 value 等于 当前查看node的节点值: 返回 真
如果 value节点值 小于 当前node节点值:
如果当前节点 有左子树 ， 继续 在 左子树 中查找该值；否则，返回 假
否则(value节点值 大于 当前node节点值):
如果当前节点 有右子树 ， 继续 在 右子树 中查找该值；否则，返回 假
示例代码：
bool BST_search(TreeNode*node, int value) {
if (node->val == value) {
return true;
}
else if (node->val > value) {
if (node->left) {
return BST_search(node->left, value);
}
else
{
return false;
}
}
else
{
if (node->right)
{
return BST_search(node->right, value);
}
else {
return false;
}
}
}
例7：二叉查找树的编码与解码
给定一个 二叉查找树 ，实现对该二叉查找树 编码与解码 功能。编码即将该二叉查找树转为 字符串 ，解码即将字符串转为 二叉查找树 。不限制使用何种编码算法，只需 保证 当对二叉查找树调用编码功能后可再调用解码功能将其 复原 。
分析：
对 二叉查找树 进行 前序遍历 ，将遍历得到的结果按顺序 重新构造 为一颗 新的 二叉查找树，新的二叉查找树与原二叉查找树 完全一样 。现在唯一的不同就是在数据，在遍历的过程中要加上编码的过程，在构造二叉树的时候要加上解码的过程。
①对于编码而言：
二叉查找树 编码 为字符串:将二叉查找树 前序遍历 ，遍历时将 整型的数据转为字符串 ，并将这些字符串数据 进行连接 ，连接时使用 特殊符号 分隔。
②对于解码而言：
将字符串 解码 为二叉查找树:将字符串按照编码时的 分隔符”#” ，将各个数字 逐个拆分 出来，将 第一个数字 构建为二叉查找树的 根节点 ，后面各个数字构建出的节点按解析时的顺序 插入根节点中，返回根节点，即完成了 解码 工作。
我们注意到：对于一般的二叉树而言，要根据数组或者字符串重构二叉树，至少需要两种遍历序列，才能正确还原二叉树，但是对于二叉查找树来说，根据前序遍历序列加上二叉查找树的性质就能还原一颗二叉查找树。
示例代码：
class Solution {
public:
/*整型转字符串*/
void change_int_to_string(int val, string &str_val) {
string temp;
while (val)//int转string
{
temp = val % 10 + '0';
val = val / 10;
}
for (int i = temp.size(); i >=0; i--)//将字符串倒置
{
str_val += temp[i];
}
str_val += '#';//以‘#’作为节点的分隔符
}
/*二叉查找树的前序遍历*/
void BST_preorder(TreeNode*node, string &data) {//注意要使用引用
if (!node) {
return;
}
string str_val;
change_int_to_string(node->val, str_val);//int 转string
data += str_val;
BST_preorder(node->left, data);
BST_preorder(node->right, data);
}
/*二叉查找树的反序列化*/
TreeNode*depreorder(string data) {
if (data.length()==0)
{
return nullptr;
}
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;//val记录的是字符串转为int的值，每转换完一个数，就将val置0
}
else
{
val = val * 10 + data[i] - '0';//字符串转int
}
}
for (int i = 0; i < node_vec.size(); i++)
{
BST_insert(node_vec[0], node_vec[i]);//插入二叉查找树
}
return node_vec[0];
}
};
1082
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
