分门别类刷leetcode——二分查找与分治算法（C++实现）

最新推荐文章于 2024-01-23 18:50:12 发布
最新推荐文章于 2024-01-23 18:50:12 发布
阅读量697 收藏 3
点赞数 2
分类专栏： 刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29996285/article/details/86602671
版权

目录

基础复习——二分查找

递归实现二分查找（递归和时间复杂度没有关系）

leetcode 35 搜索插入位置

leetcode 34 在排序数组中查找元素的第一个和最后一个位置

leetcode 33 搜索旋转排序数组

基础复习——分治法

归并排序

leetcode 315 计算右侧小于当前元素的个数

leetcode 23 合并K个排序链表

基础复习——二分查找

 

递归实现二分查找（递归和时间复杂度没有关系）

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(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 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

思路：

顺序查找，过了，时间复杂度是O(n)，目测面试官不会满意。

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        if(nums.size()<1) return 0;
        
        for(int i=0; i<nums.size(); i++){
            if(nums[i]>=target)
                return i;
        }
        return nums.size();
    }
};

 

用二分查找吧。

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]){
                    index=mid+1;
                }
                begin=mid+1;
            }
        }
        return index;
    }
};

 

 

 

leetcode 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]

思路：

用顺序查找的话，这题不难，二分查找的话，分别找左端点和右端点。写一下二分查找吧。

class Solution {
public:
    int left_bound(std::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 || nums[mid -1] < target){
                    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;
                }
                begin=mid+1;
            }else if(target<nums[mid]){
                end=mid-1;
            }else if(target>nums[mid]){
                begin=mid+1;
            }
        }
        return -1;
    }
    
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int>result;
        result.push_back(left_bound(nums, target));
        result.push_back(right_bound(nums, target));
        return result;
    }
};

 

 

 

leetcode 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

思路：

使用二分查找。将数组一分为二，其中一定有一个是有序的，另一个可能是有序，也能是部分有序。此时有序部分用二分法查找。无序部分再一分为二，其中一个一定有序，另一个可能有序，可能无序。

因此查找过程分为两种情况

  1. target<nums[mid]
  2. target>nums[mid]

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;
            //情况一：target<nums[mid]
            else if(target<nums[mid]){
                //说明nums[begin]到nums[mid]为有序递增区间。该区间单纯的二分查找即可
                if(nums[begin]<nums[mid]){
                    if(target>=nums[begin]){
                        end=mid-1;
                    }else{
                        begin=mid+1;
                    }
                //说明nums[mid+1]都numerical[nums.size()-1]为有序区间
                }else if(nums[begin]>nums[mid]){
                    end=mid-1;
                //说明此时数组中只有两个元素[6,1],target的值为1
                }else if(nums[begin]==nums[mid]){
                    begin=mid+1;
                }
            //情况二：target>nums[mid]
            }else if(target>nums[mid]){
                //mid左侧有序
                if(nums[begin]<nums[mid]){
                    begin=mid+1;
                }else if(nums[begin]>nums[mid]){
                    //说明mid到数组末尾为有序递增
                    if(target>=nums[begin]){
                        //说明目标区间在mid左侧，那段无序区间中
                        end=mid-1;
                    }else{
                        begin=mid+1;
                    }
                }else if(nums[begin]==nums[mid]){
                    begin=mid+1;
                }
            }
        }
        return -1;
    }
};

 

 

 

基础复习——分治法

 

归并排序

递归写法

class Solution {
public:
    //归并两个已排序数组
    void merge_sort_two_vec(vector<int>&sub_vec1, vector<int>&sun_vec2,
                            vector<int>&vec){
        int i=0, j=0;
        while(i<sub_vec1.size()&&j<sub_vec2.size()){
            if(sub_vec1[i]<sub_vec2[j]){
                vec.push_back(sub_vec1[i]);
                i++;
            }else{
                vec.push_back(sub_vec2[j]);
                j++;
            }
        }
        for(;i<sub_vec1.size();i++){
            vec.push_back(sub_vec1[i]);
        }
        for(;j<sub_vec2.size();j++){
            vec.push_back(sub_vec2[j]);
        }
    }
    
    void merge_sort(vector<int>&vec){
       if(vec.size()<2) return;
        
        int mid=vec.size()/2;
        vector<int>sub_vec1;
        vector<int>sub_vec2;
        for(int i=0; i<mid; i++){
            sub_vec1.push_back(vec[i]);
        }
        for(int i=mid; i<vec.size();i++){
            sub_vec2.push_back(vec[i]);
        }
        merge_sort(sub_vec1);
        merge_sort(sub_vec2);
        vec.clear();
        merge_sort_two_vec(sub_vec1, sub_vec2, vec);
    }
};

 

 

 

leetcode 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 个更小的元素.

思路：

class Solution {
public:
    vector<int> countSmaller(vector<int>& nums) {
        vector<int>count;
        if(nums.empty()) return count;
        
        vector<pair<int, int>>vec;
        //把每个值以及他在数组中的位置作为pair
        for(int i=0; i<nums.size(); i++){
            vec.push_back(make_pair(nums[i],i));
            count.push_back(0);
        }
        merge_sort(vec, count);
        return count;
    }
private:
    //归并
    void merge_sort_two_vec(vector<pair<int, int>>&sub_vec1,
                            vector<pair<int, int>>&sub_vec2,
                            vector<pair<int, int>>&vec,
                            vector<int>&count){
        int i=0, j=0;
        while(i<sub_vec1.size()&&j<sub_vec2.size()){
            if(sub_vec1[i].first<=sub_vec2[j].first){
                count[sub_vec1[i].second]+=j;
                vec.push_back(sub_vec1[i]);
                i++;
            }else{
                vec.push_back(sub_vec2[j]);
                j++;
            }
        }
        for(; i<sub_vec1.size(); i++){
            count[sub_vec1[i].second]+=j;
            vec.push_back(sub_vec1[i]);
        }
        for(; j<sub_vec2.size(); j++){
            vec.push_back(sub_vec2[j]);
        }
    }
    
    //拆分
    void merge_sort(vector<pair<int, int>>&vec, vector<int>&count){
        if(vec.size()<2)
            return;
        int mid=vec.size()/2;
        vector<pair<int, int>>sub_vec1;
        vector<pair<int, int>>sub_vec2;
        for(int i=0; i<mid; i++){
            sub_vec1.push_back(vec[i]);
        }
        for(int i=mid; i<vec.size();i++){
            sub_vec2.push_back(vec[i]);
        }
        merge_sort(sub_vec1,count);
        merge_sort(sub_vec2,count);
        vec.clear();
        merge_sort_two_vec(sub_vec1, sub_vec2, vec, count);
    }
};

 

 

 

leetcode 23 合并K个排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

方法一：把所有节点都存入数组中，然后对数组进行排序。再将排序好的各个值存入一个新链表中——目测这种方法面试官不喜欢

bool cmp(const ListNode *a, const ListNode *b){
    return a->val<b->val;
}

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        vector<ListNode*>node_vec;
        for(int i=0; i<lists.size();i++){
            ListNode *head=lists[i];
            while(head){
                node_vec.push_back(head);
                head=head->next;
            }
        }
        if(node_vec.size()==0){
            return NULL;
        }
        sort(node_vec.begin(),node_vec.end(), cmp);
        for(int i=1; i<node_vec.size();i++){
            node_vec[i-1]->next=node_vec[i];
        }
        node_vec[node_vec.size()-1]->next=NULL;
        return node_vec[0];
    }
};

 

方法二：分治归并

合并两个单链表的步骤：

  1. 先检查两个链表是否都非空，如果存在空链接，则返回另一个链表的头结点
  2. 然后设置一个空指针，使其指向两个链表中头结点值较小的节点，将该指针作为结果链表的头结点
  3. 之后进入循环体，不断比较，直到有一方的链表到达了尾节点为止
  4. 最后连接剩余的未参与比较的链表段
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        //1
        if((!l2)||(!l1)){ //如果存在空链表，则返回另一个链表的头结点
            if(l1){
                return l1;
            }else{
                return l2;
            }
        }
        
        //2
        ListNode *result=(l1->val>l2->val)?l2:l1;//结果的头结点
        if(result==l1){
            l1=l1->next;
        }else if(result==l2){
            l2=l2->next;
        }
        
        //3
        ListNode *helper=result;
        while(l1&&l2){
            if(l1->val>l2->val){
                helper->next=l2;
                l2=l2->next;
            }else{
                helper->next=l1;
                l1=l1->next;
            }
            helper=helper->next;
        }
        
        //4
        //连接l1或l2的剩余节点
        if(l1){
            helper->next=l1;
        }else if(l2){
            helper->next=l2;
        }        
        return result;
    }

       
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return NULL;
        if(lists.size()==1) return lists[0];
        if(lists.size()==2) return mergeTwoLists(lists[0], lists[1]);
        
        int mid=lists.size()/2;
        vector<ListNode*>sub1_lists;
        vector<ListNode*>sub2_lists;
        for(int i=0; i<mid; i++){
            sub1_lists.push_back(lists[i]);
        }
        for(int i=mid; i<lists.size(); i++){
            sub2_lists.push_back(lists[i]);
        }
        ListNode *l1=mergeKLists(sub1_lists);
        ListNode *l2=mergeKLists(sub2_lists);
        return mergeTwoLists(l1, l2);
    }
};

王小闹儿
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++之——分治（1）
jinyiming911的博客
07-28 1166
C++之——分治 分治”是一种常用的解题策略。它是将一个难以直接解决的大问题，分解成若干规模较小的、相互独立的、相同或类似的子问题，分而治之，再合成得到问题的解。根据“平衡子问题”的思想，一般会把问题分解成两个规模相等的子问题，也就是“二分法”，比如经典的二分查找（折半查找）问题。 例题——金块问题 【问题描述】 一个老板有一袋金块，里面有n块金块。每个月，老板会从袋子中拿出两块 金块奖励两名表现优秀的雇员。按规矩，最优秀的雇员将得到袋中最重的金块， 排名第二的雇员将得到袋中最轻的金块。如果老板周期性地往袋
【c++】分治算法
bhffvhjbjjikiffg的博客
07-17 772
【问题】计算a^n mod k的值，其中n<=109我们用分治思想进行考虑划分：如果n是偶数，则考虑x=n div 2否则考虑x=(n-1) div 2递归求解：计算a^x。合并：如果n是偶数，则a^n=(a^x)2 ，否则a^n=(a^x)^2*a最终得出程序int x;
算法-分治法（C++)
Mian_Zhi的博客
09-20 1386
C++算法题
LeetCode刷题 -- 分治算法
qq_43325216的博客
10-13 250
就是把一个复杂的问题分成两个或者更多相同或者相似的子问题（分），在把子问题分成更小的子问题...一直到最后的子问题可以简单的直接求解出来，那么原问题的解就是分出来的这些子问题的合并（治）。n为偶数时：x^n = x^(n/2) * x^(n/2) ===》这个场景不需要考虑n的正负。x^n = x^(n/2) * x^(n/2) * x ===》n为正数。x^n = x^(n/2) * x^(n/2) / x ===》n为负数。3、合并：将已求解的各个子问题的解，逐步合并为原问题的解。
c++分治
sync_async的博客
02-09 487
学习c++分治算法的看过来~~~
leetcode 704 二分查找
06-24
虽然题目是很简单，但是对于细节进行了补充
分类整理leetcode算法题解，代码语言采用c++与python实现.zip
08-23
分类整理leetcode算法题解，代码语言采用c++与python实现.zip 本资源中的源码都是经过本地编译过可运行的，下载后按照文档配置好环境就可以运行。资源项目源码系统完整，内容都是经过专业老师审定过的，基本能够满足...
刷leetcode的记录，C++和Python两种语言的实现.zip
最新发布
03-16
刷leetcode的记录，C++和Python两种语言的实现.zip刷leetcode的记录，C++和Python两种语言的实现.zip刷leetcode的记录，C++和Python两种语言的实现.zip刷leetcode的记录，C++和Python两种语言的实现.zip刷leetcode的...
与谷歌高材生一起轻松刷LeetCode探索C++编程技巧分享刷题笔记
05-23
按照题目类型的数量分类，其中最常见的几个题型包括数组、动态规划、数学、字符串、树、哈希表、深度优先搜索、二分查找、贪心算法、广度优先搜索、双指针等。这些题型以及其他流行的题型按照难易程度和类型进行了...
C++分治（分而治之）算法：将复杂问题化繁为简
LBZ的博客
01-23 523
分治算法是一种自顶向下的问题求解方法，其基本思想是将一个问题分解成多个规模较小且相互独立的子问题，每个子问题都可以独立地求解得到结果，然后将这些结果合并得到原问题的解。分治算法通常采用递归的方式实现，将大问题拆解成小问题，从而降低问题的复杂度。它将一个复杂的问题分解成若干个规模较小且相互独立的子问题，并通过递归地解决这些子问题来得到最终的结果。本文介绍了C++中实现分治算法的基本原理及示例，希望读者对该算法有更深入的理解，并能灵活应用于实际问题中。问题描述：给定n个整数的数组arr，求解这些整数的和。
分治法实现二分搜索(c语言)
01-03
分治法实现二分搜索(c语言)
c++实现二分搜索算法分析与设计分治算法
04-18
用C++实现的二分搜索，改写了算法设计与分析课后的题目。按照《算法分析与设计》书上的例题的算法实现的。采用了分治法的思想。
分治法实现二分查找算法实现
01-11
分治法实现二分查找算法实现 分治法实现二分查找算法实现 分治法实现二分查找算法实现
二分检索（分治法）
11-17
给定递增整数序列L，其大小为n，要求使用二分查找法查找任意元素的位置k(序列中第几个)
分治算法实验
12-14
1、集合划分问题 2、最大子矩阵和 题目描述： 给定一个n*n(0<n<=100)的矩阵，请找到此矩阵的一个子矩阵，并且此子矩阵的各个元素的和最大，输出这个最大的值。
分治算法C++详解
m0_54615144的博客
08-01 1819
分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。
分治算法C++
weixin_53235736的博客
03-23 1049
整数划分 整数划分是分治的应用 题目 将正整数nnn表示成一系列正整数之和。n=n1+n2+⋅⋅⋅+nk(n1≥n2≥⋅⋅⋅≥nk≥1,k≥1)n=n_1+n_2+···+n_k(n_1\geq n_2\geq···\geq n_k\geq 1,k\geq 1)n=n1​+n2​+⋅⋅⋅+nk​(n1​≥n2​≥⋅⋅⋅≥nk​≥1,k≥1)。正整数n的这种表示称为正整数的划分。 问有多少中不同的划分方法 输入 第一行输入一个整数nnn 输出 输入划分方法的总数 解析 通过题目可知，一个整数nnn可以有很多种
Leetcode 题解 - 分治算法
qq_42874319的博客
05-27 789
Leetcode 题解 - 分治算法 其实，回溯、分治和动态规划算法可以划为一类，因为它们都会涉及递归。 回溯算法就一种简单粗暴的算法技巧，说白了就是一个暴力穷举算法，比如让你用回溯算法求子集、全排列、组合，你就穷举呗，就考你会不会漏掉或者多算某些情况。 动态规划是一类算法问题，肯定是让你求最值的。因为动态规划问题拥有最优子结构，可以通过状态转移方程从小规模的子问题最优解推导出大规模问题的最优解。 ==分治算法呢，可以认为是一种算法思想，通过将原问题分解成小规模的子问题，然后根据子问题的结果构造出原问题的答
C++分治算法
m0_61033277的博客
07-24 1173
分治算法的核心思想就是“分而治之”。 大概的流程可以分为三步：分解 -> 解决 -> 合并。
leetcode分治算法
04-21
很高兴回答你的问题！LeetCode是一个编程题库和社区，其中包含了很多分治算法的题目。分治算法是一种常见的算法思想，将问题分解成一些子问题，然后分别求解这些子问题，最终将子问题的结果合并起来得到原问题的解。分治算法一般包括三个步骤：分解、解决和合并。在LeetCode上学习分治算法会对你的编程技能有很大的帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值