【算法】利用分治思想解算法题：快排、归并、快速选择实战（C++）

最新推荐文章于 2024-03-01 18:39:10 发布
最新推荐文章于 2024-03-01 18:39:10 发布
阅读量1.1k 收藏 15
点赞数 26
分类专栏： 算法 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dreaming_TI/article/details/135313018
版权

1. 分治思想 介绍

分治法将问题划分成多个相互独立且相同或类似的子问题，然后递归地解决每个子问题，并将结果合并以得到原始问题的解。

分治思想通常包含以下三个步骤：

  1. 分解：将原始问题划分成多个规模较小、相互独立且类似的子问题。这个步骤可以通过递归方法实现。
  2. 解决：递归地解决每个子问题。当子问题足够小而可以直接求解时，使用简单的方法解决。
  3. 合并：将各个子问题的解合并，得到原始问题的解。

核心思想

是将一个复杂的问题分解成多个简单的子问题，通过递归地解决子问题，最终将子问题的解合并成原始问题的解。

我们也遇到过一些，例如：归并排序、快速排序、二叉树的遍历等。

优缺点

优点在于能够有效地降低问题的复杂度，提高算法的效率。缺点在于需要额外的空间和时间来处理子问题的合并过程。

2. 分治思想 引入

75.颜色分类

在这里插入图片描述
思路

  • 题意分析：数组中只有三种元素0、1、2，要求按照012的顺序对数组进行原地排序
  • 解法一：排序
    • 我们想当然的可以想到用排序解决，这个解法也不用多说
  • 解法二：三指针划分数组
    • 数组中只有三种元素，我们利用三个指针
      在这里插入图片描述
  • 如上图所示

代码

void sortColors(vector<int>& nums) {
    // 三个指针划分区域
    // [0, left-1] : 0
    // [left, i] : 1
    // [i, right-1] : 未检测
    // [right, n-1] : 2
    int left = -1, i = 0, right = nums.size();
    while(i < right) // i，right相遇，全部检索完成
    {
        if(nums[i] == 0){
            swap(nums[++left], nums[i++]);
        }else if(nums[i] == 1){
            ++i;
        }else{
            swap(nums[--right], nums[i]);
        }
    }
}

3. 分治 - 快排思想

912.排序数组-快排

思路

  • 解法：快速排序
    在这里插入图片描述
    • 如上图所示，快排本质就是通过一个key值将数组不断的分类排序，当所有子数组（左右区间）排序完毕后，向上返回，完成还原的操作
    • 细节注意：我们使用区间范围内的随机值作为key值，可以避免最坏情况，并均匀分割。

代码

class Solution {
public:
    // 获取随机数
    int getRandom(vector<int>& nums, int left, int right){
        int r = rand();
        return nums[r % (right - left) + left];
    }

    // 快排
    void qsort(vector<int>& nums, int l, int r){
        if(l >= r)  return;

        int left = l - 1, i = l, right = r + 1;
        int key = getRandom(nums, l, r);
        while(i < right)
        {
            if(nums[i] < key)
                swap(nums[++left], nums[i++]);
            else if(nums[i] == key)
                i++;
            else
                swap(nums[--right], nums[i]);
        }
        // [l, left] [left+1, right-1] [right,r]
        qsort(nums, l, left);
        qsort(nums, right, r);
    } 

    vector<int> sortArray(vector<int>& nums) {
        // 快排 + 三数划分 + 随机数优化
        srand(time(NULL)); // 设置随机数种子
        qsort(nums, 0, nums.size() - 1);
        return nums;
    }
};

215.数组中的第K个最大元素

在这里插入图片描述

4. 分治 - 快速选择

215.数组中的第K个最大元素

思路

我们知道堆排序可以用于解决topk问题，时间复杂度为O(nlogn)，这里在引入快速选择算法，一样可以用于解决topK问题，时间复杂度为O(n)

  • 解法：快速选择算法
    在这里插入图片描述
    • 如图所示，依然利用三数划分数组的思想：
    • 我们将数组划分为三部分，求出每一部分的长度
    • 根据k与数组长度关系，找到正确的区间，直到找到正确值

代码

class Solution {
public:
    // 获取随机数
    int getRandom(vector<int>& nums, int left, int right){ 
        return nums[rand() % (right - left + 1) + left];
    }
    
    // 快排
    int qsort(vector<int>& nums, int l, int r, int k){
        if(l == r)  return nums[l];
        
        int left = l - 1, i = l, right = r + 1;
        
        int key = getRandom(nums, l, r);
        while(i < right)
        {
            if(nums[i] < key) swap(nums[++left], nums[i++]);
            else if(nums[i] > key) swap(nums[--right], nums[i]);
            else i++;
        }
            
        // 找第k大的数
        // [l, left] [left + 1, right - 1] [right, r]
        // 区间元素个数： a b c
        // int a = left - l + 1;
        int b = (right - 1) - (left + 1) + 1, c = r - right + 1;
        if(c >= k) return qsort(nums, right, r, k); // 右区间 第k位
        else if(b + c >= k) return key;
        // else if(a >= k) qsort(nums, l, left, k-b-c);
        else return qsort(nums, l, left, k-b-c);
    }
    
    int findKthLargest(vector<int>& nums, int k) {
        // 快速选择算法
        srand(time(NULL));
        return qsort(nums, 0, nums.size() - 1, k);
   }
};

面试题17.14.最小K个数

在这里插入图片描述

思路

  • 题意分析：题目要求设计算法来返回数组中最小的k个数，我们可以使用堆排序，或者快速选择算法
  • 解法：排序 / 堆 / 快速选择
    • 对于解决类似的题，都可以有上述三种做法，但由于上一题题目要求O(n)的时间复杂度，所以选择快速选择算法
    • 这里我们依然以此思想解题
      在这里插入图片描述

代码

class Solution {
public:
    int getRandom(vector<int> &arr, int left, int right){
        return arr[rand() % (right - left + 1) + left];
    }

    void qsort(vector<int>& arr, int l, int r, int k){
        if(l >= r) return;

        int left = l - 1, i = l , right = r + 1;
        int key = getRandom(arr, l, r);
        while(i < right){
            if(arr[i] < key) swap(arr[++left], arr[i++]);
            else if(arr[i] > key) swap(arr[--right], arr[i]);
            else i++;
        }

        // [l, left] [left+1, right-1] [right, r]
        // 左区间长度: a | 中间区间长度: b
        int a = left - l + 1, b = right - left - 1;
        if(a > k) qsort(arr, l, left, k);
        else if(a + b >= k) return;
        else qsort(arr, right, r, k - a - b);
    }

    vector<int> smallestK(vector<int>& arr, int k) {
        // 三数划分 + 随机数作key + 快速选择
        srand(time(NULL)); // 设置随机数种子
        qsort(arr, 0, arr.size()-1, k);
        return vector<int>(arr.begin(), arr.begin() + k);
    }
};

5. 分治 - 归并思想

912.排序数组_归并

在这里插入图片描述

思路

在这里插入图片描述

在这里插入图片描述

  • 根据上图对比，我们知道归并与快排的区别，但两者都运用了分治的思想
  • 解法：归并
    1. 首先根据mid值递归划分数组
    2. 后向上返回，需要将两有序数组合并：
      • 通过两指针遍历数组，依次比较合并数组
      • 循环结束后将两数组中未合并的数添加
    3. 最后将合并后的数组添加到num中
    • 细节注意：我们使用全局数组tmp，用于节省递归多次创建的时间开胸啊

代码

class Solution {
public:
    vector<int> tmp; // 临时数组 当递归创建多次时，全局遍历节省时间开销

    void mergeSort(vector<int>& nums, int left, int right){
        if(left >= right) return;

        int mid = left + (right - left) / 2;
        // int mid = (left + right) >> 1;
        // 1. 数组划分
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);

        // 2. 合并数组
        int cur1 = left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid && cur2 <= right)
            tmp[i++] = nums[cur1] <= nums[cur2] ? nums[cur1++] : nums[cur2++];
            
        // 2.5 处理未遍历完的数
        while(cur1 <= mid) tmp[i++] = nums[cur1++];
        while(cur2 <= right) tmp[i++] = nums[cur2++];

        // 3. 将元素写入到nums中
        for(int i = left; i <= right; ++i)
            nums[i] = tmp[i - left];
    }

    vector<int> sortArray(vector<int>& nums) {
        // 归并排序
        tmp.resize(nums.size());
        mergeSort(nums, 0, nums.size() - 1);
        return nums;
    }
};

LCR170.交易逆序对的总数

在这里插入图片描述

思路

  • 解法一：暴力枚举

    • 首先想到的当然是暴力解法，用两层for循环
    • 外层for循环遍历数组每次固定一个数，内层for循环遍历数组寻找比其小的数。

  • 解法二：归并
    在这里插入图片描述

  • 归并

    • 我们有两种策略，即排序时选择1. 升序 2. 降序
      在这里插入图片描述

    在这里插入图片描述

    • 我们选用策略1，即升序排序解题：
      1. 首先根据mid划分数组，递归左右部分并将逆序对个数加到ret中
      2. 对左右部分执行排序操作，当nums[cur1] > nums[cur2] 时，更新ret
      3. 将未合并的元素添加
      4. 最后合并数组

代码

class Solution {
public:
    vector<int> tmp;

    // 归并排序 + 计算逆序对个数
    int mergeSort(vector<int>& nums, int left, int right){
        if(left >= right) return 0; 
        // 划分数组
        int mid = left + (right - left) / 2;
        int ret = 0; // 结果
        ret += mergeSort(nums, left, mid);
        ret += mergeSort(nums, mid + 1, right);

        // 左边部分 排序 右边部分 排序
        int cur1 = left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid && cur2 <= right){
            if(nums[cur1] <= nums[cur2])
                tmp[i++] = nums[cur1++]; // 排序
            else{
                ret += mid - cur1 + 1; // 更新结果 + 排序
                tmp[i++] = nums[cur2++];
            }
        }

        // 将未合并元素加上
        while(cur1 <= mid)  tmp[i++] = nums[cur1++];
        while(cur2 <= right)  tmp[i++] = nums[cur2++];

        // 还原数组
        for(int i = left; i <= right; ++i)
            nums[i] = tmp[i - left];

        return ret;
    }   
    
    int reversePairs(vector<int>& record) {
        tmp.resize(record.size());
        return mergeSort(record, 0, record.size()-1);
    }
};

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

在这里插入图片描述

思路

  • 题意分析：题目要求找到数组nums中 “每一位其右侧小于该位的个数”，且将该个数存放到新数组count中

  • 解法一：暴力枚举

    • 很干脆，两层for循环，前固定数，后遍历从该数到数组末尾的元素，寻找小于自己的个数，统计到count中

  • 解法二：归并
    在这里插入图片描述

    • 根据题意，我们首先创建两个全局数组分别存放临时下标与临时元素，并用index数组保存nums中所有元素下标。
    1. 根据中点划分数组 + 向左右部分递归（找左右部分 满足条件的数）
    2. 通过两指针cur1、cur2遍历数组，进行比较（一左一右）
      • 随后执行上图操作
      • 当cur1元素 > cur2元素，此时cur2后所有元素都是小于自己的，更新结果，并记录cur1元素的下标与值
      • 当cur1元素 <= cur2元素，cur2继续向右移，找符合条件的值

代码

class Solution {
public:
    vector<int> ret; // 结果数组
    vector<int> index; // 记录元素移动前原始下标
    int tmpIndex[100001]; // 临时存放下标
    int tmpNums[100001]; // 临时存放元素

    void mergeSort(vector<int>& nums, int left, int right){
        if(left >= right) return;

        // 根据中点划分数组
        int mid = left + (right-left) / 2;

        // 递归排序+找数
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);

        // 具体排序找数过程
        int cur1 = left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid && cur2 <= right){
            if(nums[cur1] <= nums[cur2]){
                tmpNums[i] = nums[cur2];
                tmpIndex[i++] = index[cur2++];
            }else{
                ret[index[cur1]] += right - cur2 + 1;
                tmpNums[i] = nums[cur1];
                tmpIndex[i++] = index[cur1++];
            }
        }
        // 排序剩余元素
        while(cur1 <= mid){
            tmpNums[i] = nums[cur1];
            tmpIndex[i++] = index[cur1++];
        }
        while(cur2 <= right){
            tmpNums[i] = nums[cur2];
            tmpIndex[i++] = index[cur2++];
        }

        // 还原数组
        for(int j = left; j <= right; ++j){
            nums[j] = tmpNums[j-left]; // tmpNums是从0开始的，所以这里还原从0-left
            index[j] = tmpIndex[j-left];
        }
    }

    vector<int> countSmaller(vector<int>& nums) {
        // 哈希思想
        int n = nums.size();
        ret.resize(n);
        index.resize(n);
        // 初始化index数组 保存原始下标
        for(int i = 0; i < n-1; ++i)
            index[i] = i;

        mergeSort(nums, 0, n-1);
        return ret;
    }
};

493.翻转对

在这里插入图片描述

思路

  • 解法一：暴力枚举

    • 两层for循环，外层循环每次固定一位数，内层循环遍历数组判断是否nums[i] > nums[j] *

  • 解法二：归并

    1. 首先关于计算翻转对的操作：
      • 利用单调性，使用同向双指针
    2. 同前面的题一样，这里有两种策略：
      • 策略一：升序
        • 计算在当前元素前，有多少元素的两倍小于自己
      • 策略二：降序
        • 计算在当前元素前，有多少元素的一半大于自己

代码

class Solution {
public:
    vector<int> tmp;

    int mergeSort(vector<int>& nums, int left, int right) {
        if (left >= right) return 0;
        int ret = 0;
        // 先计算左右两侧的翻转对
        int mid = left + (right - left) / 2;
        ret += mergeSort(nums, left, mid);
        ret += mergeSort(nums, mid + 1, right);
        
        // 计算翻转对操作
        int cur1 = left, cur2 = mid + 1;
        while(cur1 <= mid)
        {
            while(cur2 <= right && (nums[cur1] / 2.0 <= nums[cur2])) 
            	cur2++; // 找到符合条件的cur2位置，用*可能溢出
            
            if(cur2 > right) break;
            ret += right - cur2 + 1;
            ++cur1;
        }

        // 具体排序
        // 降序判断
        cur1 = left, cur2 = mid + 1;
        int i = 0;
        while(cur1 <= mid && cur2 <= right)
            tmp[i++] = nums[cur1] <= nums[cur2] ? nums[cur2++] : nums[cur1++];
        // 排序剩余元素
        while(cur1 <= mid) tmp[i++] = nums[cur1++];
        while(cur2 <= right) tmp[i++] = nums[cur2++];

        // 还原数组
        for(int j = left; j <= right; ++j)
            nums[j] = tmp[j - left];
        return ret;
    }

    int reversePairs(vector<int>& nums) {
        tmp.resize(nums.size());
        return mergeSort(nums, 0, nums.size() - 1);
    }
};
卜及中
关注
专栏目录
C++排序算法：归并排序详解
小天狼星_布莱克 的博客
07-17 3万+
C++排序算法：归并排序详解
c++实现快速选择算法
FS's Home
01-17 3131
在给定的一串序列中，选择出第k大/小的元素。 根据快速排序算法，给出一种解决方案，优点就是只对局部的一部分排序。相比与快速排序算法，快速选择是进行一次递归调用。平均时间为O(N)。 程序如下，给出了快速排序算法的结果进行对比： #include #include #include #include #include #include using namespace std; /* * 快速
分治法（算法）
热门推荐
Alingte7的博客
09-10 2万+
二分法，归并排序，快速排序，快速幂，汉诺塔
C++ 快速排序&快速选择OJ
Han同学
03-01 1087
基于三指针分块+随机选择基准元素的快速排序，并且使用快速排序进行快速选择（递归排序时进入对应期间）
快速选择算法c++
qq_41183949的博客
03-31 1904
快速选择算法c++Quick Selection原理Quick Selection复杂度分析前后指针法 Quick Selection原理 Quick Selection算法和Quick Sort算法是由同一个作者提出，这两者之间有很大的相似之处——分治，即将问题的规模一次次的减小，直到求出最终解，时间复杂度O(n)，且数据无需有序。 目标：找到第n大的数 随机产生一个pivot 根据这个piv...
C++---快速选择（每日一道算法2023.4.8）
SRestia的博客
04-08 510
给一个未排序的序列，序列中不包含重复元素，要求找到第k大的元素并输出。
分治思想的几个算法：二分检索、快排、归并排序
朱胜本的专栏
09-12 3633
/*分治思想的各种算法*/ #include #include /*二分检索算法*/ int BinarySearch(int a[],int n,int e) { int index; int low=0,high=n-1, mid; while(low <= high) { mid = (low + high) / 2;
分治算法之——快速排序算法（C++实现）
zhang35的博客
12-11 2833
快速排序是分治策略、迭代的典型示例，需要熟练掌握。 核心思想 将数组中所有元素都跟一个基准元素x比（随意选取，常取第一个或最后一个），比x小的划分成左边一块，比x大的划分成右边一块，得到两个子问题。然后递归处理这两个子问题即可。 其关键在于对数组的划分。 代码实现 下面是C++实现代码： 代码参考：常用算法之----快速排序 #include <iostream> using nam...
C++实现希尔、快速、堆排序、归并排序算法
01-21
本文将详细介绍C++中实现的希尔排序、快速排序、堆排序和归并排序这四种经典排序算法。 希尔排序，由Donald Shell于1959年提出，是一种改进的插入排序。它的基本思想是通过设置一个增量序列，将待排序的元素按照...
C++冒泡、快速、选择、归并等排序算法实现示例.rar
最新发布
05-07
归并排序是一种分治算法，它将待排序的序列分为两个子序列，分别进行排序，然后合并两个已排序的子序列以得到最终结果。归并排序总是保证稳定性，且无论输入是什么情况，其时间复杂度均为O(n log n)。由于需要额外的...
C++ 不知算法系列之从希尔、归并排序算法中的分治哲学聊起
12-29
分治算法是计算机科学中的一种重要解决问题的策略，它的核心思想是将一个复杂的问题分解成较小的、相互独立的子问题，然后分别解决这些子问题，最后将子问题的解组合起来，形成原问题的解。这个过程可以形象地用中国...
快速排序与归并排序比较(C++).rar_c++paixusuanfa_归并_归并排序_归并排序算法
09-19
C++中实现快速排序和归并排序，可以利用STL中的`std::sort`函数，但为了深入理解算法，通常会自定义实现。快速排序可以采用递归或非递归方式，而归并排序则通常使用递归。在“快速排序与归并排序比较(C++)”的程序中...
【数据结构与算法】程序员常用10种算法（分治算法）
yubao0723的专栏
04-18 657
一文搞懂分治算法
快速选择算法及C++代码
eepii的博客
02-11 1290
快速选择算法及C++代码一. 快速选择算法分析二. C++代码2.1 源代码2.2 变体三. 应用 一. 快速选择算法分析 快速选择算法是指：利用快速排序算法的思想，计算得到【给定位置（可能是第一个位置，可能是中间位置）】的数在排序后的位置的【下标】的算法。 应用场景：找出给定数组的第k大的数。如Leetcode第215题。 二. C++代码 2.1 源代码 以数组首位为例，代码如下（示例）： int quick_selection(vector<int>& nums) { int
分治算法（选择问题等）
thdwx的博客
10-27 1365
将问题分解为较小的问题，并递归解决小问题（基本情况除外）。从所有子问题的解中构建原问题的解。一般认为，在程序中至少含有两个递归的算法就是分治算法，如果只有一个递归函数（例如，快速幂等），那么通常是将原问题转化为更简单的问题来解决，例如求阶乘的递归写法：只是将n的阶乘转化成了n乘(n-1)的阶乘，并没有将原问题进行分解。在分治算法中，子问题通常是不相交的，如果子问题相交，例如斐波那契数列的递归写法，实际上并没有将问题真正分解（因为,
c++快速排序
jkkkkkkksd的专栏
01-23 347
快速排序（n个数） 从数中随便选取一个数a，（一般选取第一个数），将a与其余的数字s进行比较，若a小于s，则交换。n-1轮比较完成后。 另选一个数a，与其余n-2数分别比较，（交换），如此重复， 进行N-1轮比较。 // kspx2.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; voi
快速选择算法
Erice_s的博客
07-22 156
快速选择算法
学习ing
ghostriderk的专栏
06-12 934
快速排序及快速选择终极版
wusecaiyun的专栏
09-21 624
快速排序（Quick Sort）是一种非常经典高效的排序算法，采用了基于比较的递归分治策略，平均情况下复杂度为O(nlogn)，但最坏情况下会退化到O(n^2)。 在笔试面试过程中经常会问到有关于快速排序的问题，甚至要求面试者当场手写代码，本文将简单介绍快排原理并提供具体的代码实现，以及其在求第n小的数中的经典应用。 一 系统函数 C++的STL已经提供了快速排序的函数sor
C++基础算法：快速排序与归并排序详解
首先介绍的是快速排序，这是一种高效的通用排序算法，它采用分治策略，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小。代码展示了如何定义一个`quick_sort`函数，接收一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值