leetcode--二分查找和二分排序

最新推荐文章于 2024-07-25 01:40:26 发布
最新推荐文章于 2024-07-25 01:40:26 发布
阅读量322 收藏 1
点赞数
分类专栏： leetcode 文章标签： 机器学习 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiayto/article/details/78876070
版权

基础知识

二分法有三种情况：
1、找到那个数的位置（只需要找到其中一个）
2、找左边界
3、找右边界
通用模板：

int binary_search(int[] nums, int target) {
    int left = 0, right = nums.length - 1; 
    while(left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1; 
        } else if(nums[mid] == target) {
            // 直接返回
            return mid;
        }
    }
    // 直接返回
    return -1;
}

int left_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定左侧边界
            right = mid - 1;
        }
    }
    // 最后要检查 left 越界的情况
    if (left >= nums.length || nums[left] != target)
        return -1;
    return left;
}

int right_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定右侧边界
            left = mid + 1;
        }
    }
    // 最后要检查 right 越界的情况
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}

二分查找（递归）代码

#include <vector>
using namesape std;
bool binary_search(vector<int> &sort_array,int begin, int end, int target){
	if(begin>end){
		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,mid+1,end,target);
	}
}

二分查找（循环）代码

bool binary_search(std::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;
}

leetcode题目

##3 5. Search Insert Position

题意：

给出一个递增序列，和一个target数字，找到这个数字在递增序列中的插入位置，使插入之后还是有序。

解题思路：

普通的二分查找，要注意边界条件。

代码：

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int begin=0;
        int end=nums.size()-1;
        int index=-1;
        while(index==-1){
            int mid=(begin+end)/2;
            if(nums[mid]==target){
                index=mid;
            }
            else if(nums[mid]>target){
                if(mid==0||target>nums[mid-1]){   //注意边界的情况 
                    index=mid;
                }
                end=mid-1;
            }
            else if(nums[mid]<target){
                if(mid==nums.size()-1||target<nums[mid-1]){  //注意边界的情况
                    index=mid+1;
                }
                begin=mid+1;   
            }
        }
        return index;
    }
};

34. Search for a Range

题意：

递增序列中的元素可能重复，找到target在递增序列中的range，如果不存在输出[-1,-1]

解题思路：

用两个二分查找，分别找出左界限和右界限。

代码：

int searchLeft(vector<int>& nums,int target){
    int begin=0;
    int end=nums.size()-1;
    while(begin<=end){
        int mid=(begin+end)/2;
        if(nums[mid]==target){
            if(mid==0||nums[mid-1]<target){
                return mid;
            }
            end=mid-1;
        }
        else if(nums[mid]<target){
            begin=mid+1;
        }
        else if(nums[mid]>target){
            end=mid-1;
        }
    }
    return -1;
}

int searchRight(vector<int>& nums,int target){
    int begin=0;
    int end=nums.size()-1;
    while(begin<=end){
        int mid=(begin+end)/2;
        if(nums[mid]==target){
            if(mid==nums.size()-1||nums[mid+1]>target){
                return mid;
            }
            begin=mid+1;
        }
        else if(nums[mid]<target){
            begin=mid+1;
        }
        else if(nums[mid]>target){
            end=mid-1;
        }
    }
    return -1;
}


class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result;
        result.push_back(searchLeft(nums,target));
        result.push_back(searchRight(nums,target));
        return result;
        }
    };

33. Search in Rotated Sorted Array

题意：

在一个旋转数组中找目标元素。

解题思路：

分情况讨论的二分查找，变成一部分是顺序数组，一部分是旋转数组，每次判断是在顺序数组中还是旋转数组中，注意一些等于的边界情况。

代码：

class Solution {
public:
int search(vector& 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]){
if(target >= nums[begin]){
end = mid - 1;
}
else if(target < nums[begin]){
begin = mid + 1;
}
}
else if(nums[begin] < nums[mid]){
begin = mid + 1;
}
else if(nums[begin] == nums[mid]){
begin = mid + 1;
}

        }
        else if(target < nums[mid]){
            if(nums[begin] > nums[mid]){
                end = mid - 1;
            }
            else if(nums[begin] < nums[mid]){
                if(target >= nums[begin]){
                    end = mid - 1;
                }
                else if (target < nums[begin]){
                    begin = mid + 1;
                }
            }
            else if(nums[begin] == nums[mid]){
                begin = mid + 1;
            }
        }
    }
    return -1;
}

};

基础知识

二叉排序树数据结构：

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

二叉排序树数据查找：

用递归的方法搜索：

bool BST_search(TreeNode *node, int value){
	if (node->val == value){
		return true;
	}
	if (value < node->val){
		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;
		}
	}
}

##二叉排序树数据插入：
也是用递归的方法，当子树空就插入，不空就递归的向子树搜索

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;
		}
	}
}

Leetcode 题目

449. Serialize and Deserialize BST

题意：

给定一个二叉树，写出编码和解码的方法。
编码：将二叉树转为字符串
解码：将字符串转为二叉树

解题思路：

1、前序遍历保留二叉树，然后用特殊符号#隔开
2、遍历字符串，用二叉树的插入方法重建二叉树
建立时候的基础知识：
1、数字变字符串，用mod 10取余再反转的方法。
2、字符串变数字，用*10+x来还原，

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
void change_int_to_string(int val,string &str_val){
    string tmp;
    while(val){
        tmp += val % 10 + '0';
        val = val / 10;
    }
    for (int i = tmp.length() - 1; i>=0; i--){
        str_val += tmp[i];
    }
    str_val += '#';
}

//根节点，插入节点
void BST_insert(TreeNode *node, TreeNode *insert_node){
    if (node->val > insert_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;
        }
    }
}
//用递归进行前序遍历
void BST_preorder(TreeNode *node, string &data){
    if(!node){
        return;
    }
    string str_val;
    change_int_to_string(node->val, str_val);
    data += str_val;
    BST_preorder(node->left, data);
    BST_preorder(node->right, data);
}

class Codec {
public:
    string serialize(TreeNode* root){
        string data;
        BST_preorder(root, data);
        return data;
    }
    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. Count of Smaller Numbers After Self

题意：

输入一个数组a，返回一个相同size的数组b，b中每个元素是a中该位置的元素后面比该元素小的元素个数。

解题思路：

先将数组逆置，逐个插入数组到一个二叉搜索树中，相当于维护一个带左子树个数的二叉搜索树。

代码

void BST_insert(BSTNode *node, BSTNode *insert_node, int &count_small){
	if (insert_node->val <= node->val){
		node->count++;
		if (node->left){
			BST_insert(node->left, insert_node, count_small);
		}
		else{
			node->left = insert_node;
		}
	}
	else{
		count_small += node->count + 1;
		if (node->right){
			BST_insert(node->right, insert_node, count_small);
		}
		else{
			node->right = insert_node;
		}
	}
}

class Solution {
public:
    std::vector<int> countSmaller(std::vector<int>& nums) {
    	std::vector<int> result;
    	std::vector<BSTNode *> node_vec;
    	std::vector<int> count;
    	for (int i = nums.size() - 1; i >= 0; i--){
    		node_vec.push_back(new BSTNode(nums[i]));
	    }
	    count.push_back(0);
	    for (int i = 1; i < node_vec.size(); i++){
	    	int count_small = 0;
    		BST_insert(node_vec[0], node_vec[i], count_small);
    		count.push_back(count_small);
    	}
        for (int i = node_vec.size() - 1; i >= 0; i--){
        	delete node_vec[i];
        	result.push_back(count[i]);
        }
        return result;
    }
};
xiayto
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode-二分查找
wangdsdasdasdas的博客
08-25 198
LeetCode二分查找相关题目
颜色分类leetcode-leetcode-problems:leetcode-问题
07-06
本篇将重点探讨LeetCode中的“颜色分类”问题，并结合其他相关知识点，如数组、链表、队列、栈、排序以及二分查找等基础方法，为你的编程技能提升提供全面指导。 首先，我们来看“颜色分类”问题。这个问题通常出现...
LeetCode---二分查找
DDDDDouble的博客
10-26 332
LeetCode---二分查找二分查找条件两种情况推荐题目：扩展有序、无重复元素、查找元素存在不确定有序、重复元素、查找元素存在不确定（日后补充） 二分查找 条件 有序（升序）数组 ； 查找数量为1个 两种情况 704.二分查找（举例）： 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 第一种方法：左闭右闭 class Solution { public int sear
LeetCode-704.二分查找.C++
m0_53300448的博客
12-28 240
LeetCode-704.二分查找.C++解法 及Vector和二分查找知识补充
LeetCode Hot100 ---- 二分查找专题
摩登都市天空---专栏
07-08 311
什么是二分查找 二分查找是计算机科学中最基本、最有用的算法之一。 它描述了在有序集合中搜索特定值的过程。 二分查找中使用的术语： 目标 Target —— 你要查找的值 索引 Index —— 你要查找的当前位置 左、右指示符 Left，Right —— 我们用来维持查找空间的指标 中间指示符 Mid —— 我们用来应用条件来确定我们应该向左查找还是向右查找的索引 下面介绍三个常用的二分查找模板来源力扣：https://leetcode-cn.com/explore/learn/card/b
Leetcode刷题笔记--二分查找
qq_45795134的博客
02-27 856
之前刷了一段时间的Leetcode,当时似乎弄明白了一类题目，但是由于做的题目比较繁杂，而且没有进行总结，导致过一段时间之后有需要重新思考，又会花费大量的时间。所以我打算把之前刷过的题目类型进行一些总结与思考，以便我可以更好地掌握这些知识。今天，我打算从二分法开始进行总结。提示：以下是本篇文章正文内容，下面案例可供参考。
leetcode-二分查找算法总结
最新发布
m0_68402491的博客
07-25 620
对于右端点来说，它的二段性进行了改变：第一段：包含target的区间；(0,left]第二段：不包含target的区间。所以left和right的行为相比较与左端点的求法就需要进行改变：这里left和right的移动规则进行了改变，则mid的确定方法就得进行改变。其它注意事项和原理与求左端点基本相同.实例:模板:在遇到二分查找的问题时，我们首先根据题意确定左右指针的行为，行为确定后如果是 不朴素二分查找我们就直接通过上述模板确定循环结束条件，mid的表达式等。
LeetCode-704:二分查找(Java语言实现)
2301_78482533的博客
01-29 121
【代码】LeetCode-704:二分查找(Java语言实现)
Leetcode刷题笔记：二分查找算法
yumuing‘s blog
01-09 1112
LeetCode 对于数组查询算法之一的二分查找算法的简单认识。
leetcode-hot100-二分查找
qq_41784433的博客
11-12 2373
文章目录[4. 寻找两个正序数组的中位数 - 力扣（LeetCode） (leetcode-cn.com)](https://leetcode-cn.com/problems/median-of-two-sorted-arrays/)[33. 搜索旋转排序数组 - 力扣（LeetCode） (leetcode-cn.com)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) 4. 寻找两个正序数组的中位数 - 力扣（Leet
LeetCode刷题笔记：二分查找简单进阶
yumuing‘s blog
01-09 724
对于二分算法的简单进阶认识，利用两道LeetCode题型巩固认识！
leetcode分类-leetcode-solution:leetcode-解决方案
06-29
每一道LeetCode题目的解决方案都是一段实现特定算法的代码，涵盖了诸如暴力法、哈希表、二分查找、动态规划等多种经典算法。通过阅读和理解这些代码，我们可以深化对算法的理解，提高编程效率，并且能够应用于实际的...
leetcode分类-LeetCode-mac:等
06-30
8. **排序和搜索**：快速排序、归并排序、二分查找等高效算法。 9. **动态规划**：解决具有重叠子问题和最优子结构的问题，如背包问题、最长递增子序列等。 10. **回溯**：用于寻找所有可能的解决方案，如八皇后问题...
leetcode答案-LeetCode-Python:LeetCode-Python
06-30
- 查找算法：线性查找、二分查找、哈希查找。 - 树结构：二叉树、平衡树（AVL、红黑树）、堆（大顶堆、小顶堆）。 - 链表：单链表、双链表、环形链表的操作。 - 栈与队列：后进先出（LIFO）和先进先出（FIFO）的...
leetcode答案-LeetCode-Answers:LeetCode-答案
06-30
例如，二分查找、动态规划、贪心算法等都是LeetCode中常见的主题。 6. **面试准备**：很多公司在面试中会用到LeetCode上的问题，熟悉这些解答能帮助你在面试中表现出色。 总的来说，"LeetCode-Answers-master"是一...
归并排序练习题（Java）
xiayto的博客
07-25 815
1、算法原理： 首先归并排序的基本是将两个数组合并，将两个有序的数组合并为一个有序的数组，需要一个额外的辅助数组，例如a、b数组，合并为c c[0] 是 a[0] 和 b[0] 中较小的数，假设是a[0]，然后a数组的指针加1 变为a[1] c[1] 是 a[1] 和 b[0] 中较小的数，如此类推 这样进行一次合并时间复杂度是O(n) 归并排序的思想是，将整个数组2等分地无限拆分为每组只有1...
leetcode--递归、回溯和分治
xiayto的博客
11-06 780
基本概念leetcode题目78. Subsets题意：给出一个数列，求出这个数列所有子集解题思路：用递归解决，设计思路： 数据结构： 一个vector<int> item存储集合 一个vector<vector<int>>result 存储结果 递归程序： generate(i,nums,item,result) 递归程序含义：nums[i]前所有元素+nums[i]后所有元素组成的
背包问题及其变体（Java）
xiayto的博客
07-26 717
背包问题： 最经典的0-1背包 背包问题是有一个一定容量的背包，然后有一堆物品，这些物品有一定的重量，要求在不超过背包容量的情况下，装最多的重量的问题。 背包问题的变体 背包问题有很多的变体，主要有以下几个： 物品不仅仅有重量还会对应不同的价值，求价值最高，而不是重量最高 每个物品有无限个而不是只有一个 不是求最大重量，而是求达到重量的组合的个数 背包问题的解法： 背包问题是用动态规划的方法解...
leetcode--栈和队列
xiayto的博客
10-29 638
基本操作：STL stack#include <stack> S.top()：取出栈顶 S.empty()：判断栈是否为空 S.push(x)：将x压入栈中 S.pop()：弹出栈顶 S.size()：栈的存储元素个数STL queue#include <queue> Q.empty()：判断队列是否为空 Q.front()：返回队列的头部元素 Q.back()：返回队列的尾部元素
LeetCode挑战：单元素排序数组与硬币组合
由于数组已经排序，我们可以使用二分查找的方法。首先，找到数组中间的元素，然后检查其左边和右边的元素。如果中间元素与其左边或右边的元素相同，那么单次出现的元素必然在另一侧。通过不断调整搜索范围，最终我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值