算法：归并排序面试题

已于 2022-08-11 11:12:12 修改
阅读量334 收藏 1
点赞数
分类专栏： 算法与数据结构 文章标签： golang 算法
于 2020-05-07 17:19:31 首次发布
原文链接：https://blog.csdn.net/qq_52880445/article/details/122857781?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-0-122857781-blog-86555134.pc_relevant_default&spm=1001.2101.3001.4242.1&utm_relevant_index=3
版权

小和问题

题目描述

在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。

举个栗子

{1,3,4,2,5}
1左边比1小的数，没有
3左边比3小的数，1；
4左边比4小的数，1、3；
2左边比2小的数，1；
5左边比5小的数，1、3、4、2；
所以小和为1+1+3+1+1+3+4+2=16

题目解析

第一种思路就是暴力递归：

  • 使用一个指针，对于每一个 n u m s [ i ] nums[i] nums[i]，往左看，把比它小的数加起来，最终得到结果
  • 这种方法时间复杂度为O(N^2)。

这样时间复杂度太高了，所以我们可以转换一个思路

  • 题目要求找左边数比它小的数字相加，那么我们可以转变为看看右边有多少个数字比它大（假设为n），表示该数在小和的计算中出现了n次，最后相加即可（可以通过归并排序在进行排序的同时拿到它的小和）
  • 即1右边比1大的数有4个，3右边比3大的数有2个，4右边比4大的数有1个，2右边比2大的数有1个，5右边没有数。小和=14+32+41+21=16
  • 同时判断右边比左边大的数的多少是通过排序然后计算数组得到的。
    在这里插入图片描述

另外，如果合并的时候相等怎么办？

在这里插入图片描述

这个为什么快呢？因为在求小和的过程中后边子数组已经是有序的了，只要求出它的长度，在乘以当前数组的长度就可以求出小和的大小了，而不需要再遍历数组。

#include <iostream>
#include <vector>
#include <memory>
#include <list>
#include <random>

using namespace std;




int merge(std::vector<int> & nums, int left, int mid, int right){
    int ans = 0;
    std::vector<int>  help(right - left + 1);
    int p1 = left, p2 = mid + 1, i = 0;
    while (p1 <= mid && p2 <= right){
        ans += nums[p1] < nums[p2] ? (right - p2 + 1) * nums[p1] : 0;
        help[i++] = nums[p1] < nums[p2] ? nums[p1++] : nums[p2++];
    }

    while (p1 <= mid){
        help[i++] = nums[p1++];
    }

    while (p2 <= right){
        help[i++] = nums[p2++];
    }

    i = 0;
    for (int j = left; j <= right; ++j) {
        nums[j] = help[i++];
    }
    return ans;
}

// arr[L..R]既要排好序，也要求小和返回
// 所有merge时，产生的小和，累加
// 左 排序   merge
// 右 排序  merge
// merge
int process(std::vector<int> & nums, int left, int right){
    if(left == right){
        return 0;
    }

    int mid = left + (right - left) / 2;
    return  process(nums, left, mid)  +
            process(nums, mid + 1, right) +
            merge(nums, left, mid, right);
}

int smallSum(std::vector<int>  &nums){
    if(nums.empty()){
        return 0;
    }
    return process(nums, 0, (int)nums.size() - 1);
}


int comparator(std::vector<int>  &nums){
    if(nums.empty() || nums.size() < 2){
        return 0;
    }

    int res = 0;
    int size = nums.size();
    for (int i = 1; i < size; ++i) {
        for (int j = 0; j < i; ++j) {
            res += (nums[j] < nums[i]) ? nums[j] : 0;
        }
    }

    return res;
}

std::default_random_engine e;
std::vector<int>  gen_randomArray(int maxLen, int minValue, int maxValue){
    std::uniform_int_distribution<int> distS(0, maxLen);
    std::uniform_int_distribution<int> distV(minValue, maxValue);
    int size = distS(e);
    std::vector<int> result(size);
    for (int i = 0; i < size - 1; ++i) {
        result[i] = distV(e);
    }
    return result;
}

std::vector<int> copy_Array(std::vector<int> &nums){
    std::vector<int> res;
    res.reserve(nums.size());
    for(auto num : nums){
        res.emplace_back(num);
    }
    return res;
}
void printVec(std::vector<int> & nums){
    for(auto num : nums){
        std::cout << num << "\t";
    }
    std::cout << "\n\n";
}

int main() {
    e.seed(time(NULL));

    int maxLen = 10;
    int minValue = 0;
    int maxValue = 10;
    bool  success = true;
    for (int i = 0; i < 100; ++i) {
        auto num1 = gen_randomArray(maxLen, minValue, maxValue);
        auto num2 = copy_Array(num1);
        int a = smallSum(num1);
        int b = comparator(num2);
        if(a != b){
            success = false;
            std::cout << a << "," << b << "\n";
            break;
        }
    }

    if(success){
        std::cout << "ok!";
    }else{
        std::cout << "error!";
    }

    return 0;
}

小结：

  • 左组的数小于右组的数时，产生小和，左指针右移；
  • 左组的数等于右组时，直接拷贝右组，不产生小和；
  • 左组的数大于右组时，直接拷贝右移，不产生小和。

逆序对

题目来源

题目描述

在这里插入图片描述

例如，数组（3，1，4，5，2）的逆序对有(3,1),(3,2),(4,2),(5,2)，共4个。

题目解析

和上面的那道题类似，上面是看右边有多少个数字比它大；这里是，转变为看看右边有多少个数字比它小的个数，或者说，左边有多少个数比它大。

在这里插入图片描述

在这里插入图片描述

#include <iostream>
#include <vector>
#include <memory>
#include <list>
#include <random>

using namespace std;


int merge2(std::vector<int> & nums, int left, int mid, int right){
    int ans = 0;
    std::vector<int> help(right - left + 1);
    int p1 = mid, p2 = right, i = (int)help.size() - 1;
    while (p1 >= left && p2 >= mid + 1 ){
        ans += nums[p2] >= nums[p1] ?
              0 :                         // 右边的更大一些当然不产生逆序对
              (p2 - (mid + 1) + 1);
        help[i--] = nums[p2] >= nums[p1] ? nums[p2--] : nums[p1--];
    }

    while (p1 >= left){
        help[i--] = nums[p1--];
    }
    while (p2 >= mid + 1){
        help[i--] = nums[p2--];
    }

    i = 0;
    for (int j = left; j <= right; ++j) {
        nums[j] = help[i++];
    }
    return ans;
}


int merge(std::vector<int> & nums, int left, int mid, int right){
    int ans = 0;
    std::vector<int>  help(right - left + 1);
    int p1 = left, p2 = mid + 1, i = 0;
    while (p1 <= mid && p2 <= right){
        ans +=   nums[p1] <= nums[p2] ?  0 : mid - p1 + 1 ;
        help[i++] = nums[p1] <= nums[p2] ? nums[p1++] : nums[p2++];
    }

    while (p1 <= mid){
        help[i++] = nums[p1++];
    }

    while (p2 <= right){
        help[i++] = nums[p2++];
    }

    i = 0;
    for (int j = left; j <= right; ++j) {
        nums[j] = help[i++];
    }
    return ans;
}

// arr[L..R]既要排好序，也要求小和返回
// 所有merge时，产生的小和，累加
// 左 排序   merge
// 右 排序  merge
// merge
int process(std::vector<int> & nums, int left, int right){
    if(left == right){
        return 0;
    }

    int mid = left + (right - left) / 2;
    return  process(nums, left, mid)  +
            process(nums, mid + 1, right) +
            merge2(nums, left, mid, right);
}

int reversePairs(std::vector<int>  &nums){
    if(nums.empty()){
        return 0;
    }
    return process(nums, 0, (int)nums.size() - 1);
}


int comparator(std::vector<int>  &nums){
    if(nums.empty() || nums.size() < 2){
        return 0;
    }

    int res = 0;
    int size = nums.size();
    for (int i = 0; i < size - 1; ++i) {
        for (int j = i + 1; j < size; ++j) {
            res += nums[i] > nums[j] ? 1 : 0;
        }
    }

    return res;
}

std::default_random_engine e;
std::vector<int>  gen_randomArray(int maxLen, int minValue, int maxValue){
    std::uniform_int_distribution<int> distS(0, maxLen);
    std::uniform_int_distribution<int> distV(minValue, maxValue);
    int size = distS(e);
    std::vector<int> result(size);
    for (int i = 0; i < size - 1; ++i) {
        result[i] = distV(e);
    }
    return result;
}

std::vector<int> copy_Array(std::vector<int> &nums){
    std::vector<int> res;
    res.reserve(nums.size());
    for(auto num : nums){
        res.emplace_back(num);
    }
    return res;
}
void printVec(std::vector<int> & nums){
    for(auto num : nums){
        std::cout << num << "\t";
    }
    std::cout << "\n\n";
}

int main() {
    e.seed(time(NULL));

    int maxLen = 10;
    int minValue = 0;
    int maxValue = 10;
    bool  success = true;
    for (int i = 0; i < 100; ++i) {
        auto num1 = gen_randomArray(maxLen, minValue, maxValue);
        auto num2 = copy_Array(num1);
        int a = reversePairs(num1);
        int b = comparator(num2);
        if(a != b){
            success = false;
            std::cout << a << "," << b << "\n";
            break;
        }
    }

    if(success){
        std::cout << "ok!";
    }else{
        std::cout << "error!";
    }

    return 0;
}

翻转对

题目来源

题目描述

在这里插入图片描述
人话就是：在一个数组中，对于每个数num，求有多少个后面的数 * 2 依然＜num，求总个数。比如：[3,1,7,0,2]，3的后面有：1，0；1的后面有：0；7的后面有：0，2；0的后面
在这里插入图片描述

题目解析

#include <iostream>
#include <vector>
#include <memory>
#include <list>
#include <random>

using namespace std;





int merge(std::vector<int> & nums, int left, int mid, int right){
    int ans = 0;
    int windowL = mid , windowR = mid + 1;  // [windowL, windowR)
    for (int i = left; i <= mid; ++i) {
        // 判断windowsR是否可以纳入
        while (windowR <= right && (long)nums[i] > (long)2 * nums[windowR]){
            windowR++;
        }

        ans += (windowR  - 1 ) - windowL;
    }
    std::vector<int>  help(right - left + 1);
    int p1 = left, p2 = mid + 1, i = 0;
    while (p1 <= mid && p2 <= right){
        help[i++] = nums[p1] <= nums[p2] ? nums[p1++] : nums[p2++];
    }

    while (p1 <= mid){
        help[i++] = nums[p1++];
    }

    while (p2 <= right){
        help[i++] = nums[p2++];
    }

    i = 0;
    for (int j = left; j <= right; ++j) {
        nums[j] = help[i++];
    }
    return ans;
}


int process(std::vector<int> & nums, int left, int right){
    if(left == right){  // 递归的出口：不能再二分了，返回
        return 0;
    }

    int mid = left + (right - left) / 2;
    return  process(nums, left, mid)  +
            process(nums, mid + 1, right) +
            merge(nums, left, mid, right);
}

int reversePairs(std::vector<int>  &nums){
    if(nums.empty()){
        return 0;
    }
    return process(nums, 0, (int)nums.size() - 1);
}


int comparator(std::vector<int>  &nums){
    if(nums.empty() || nums.size() < 2){
        return 0;
    }

    int res = 0;
    int size = nums.size();
    for (int i = 0; i < size - 1; ++i) {
        for (int j = i + 1; j < size; ++j) {
            res += nums[i] > 2 * nums[j] ? 1 : 0;
        }
    }

    return res;
}

std::default_random_engine e;
std::vector<int>  gen_randomArray(int maxLen, int minValue, int maxValue){
    std::uniform_int_distribution<int> distS(0, maxLen);
    std::uniform_int_distribution<int> distV(minValue, maxValue);
    int size = distS(e);
    std::vector<int> result(size);
    for (int i = 0; i < size - 1; ++i) {
        result[i] = distV(e);
    }
    return result;
}

std::vector<int> copy_Array(std::vector<int> &nums){
    std::vector<int> res;
    res.reserve(nums.size());
    for(auto num : nums){
        res.emplace_back(num);
    }
    return res;
}
void printVec(std::vector<int> & nums){
    for(auto num : nums){
        std::cout << num << "\t";
    }
    std::cout << "\n\n";
}

int main() {
    e.seed(time(NULL));

    int maxLen = 10;
    int minValue = 0;
    int maxValue = 10;
    bool  success = true;
    for (int i = 0; i < 100; ++i) {
        auto num1 = gen_randomArray(maxLen, minValue, maxValue);
        auto num2 = copy_Array(num1);
        printVec(num1);
        int a = reversePairs(num1);
        int b = comparator(num2);
        if(a != b){
            success = false;
            std::cout <<  "get [" << a << "] ,but should [" << b << "]\n";
            break;
        }
    }

    if(success){
        std::cout << "ok!";
    }else{
        std::cout << "error!";
    }

    return 0;
}

参考

OceanStar的学习笔记
关注
专栏目录
算法笔记-归并算法面试题、小和问题
这是一个机械转编程的博客
09-24 204
算法笔记-归并算法面试题、小和问题
排序算法：归并排序
m0_69745974的博客
04-29 575
例子 == 下面通过一个例子来看看归并排序是怎么工作的，原数组如下。 第一步：分解 首先将数组分解成两部分，即19、15、37为一组，12、25为一组，为了区分，我们起个名字叫“第一层”，如下图： 第二步：分解 继续分解，19、15为一组，37为一组，12为一组，25为一组，这四组为“第二层”，如下图： 第三步：分解 继续分解，此时只剩下19、15这一组可以分解，分解成19、15，这两组为“第三层”，如下图： 第四步：归并 由于所有组都已经分解成只有1个元素，开始进行归并，从“高层”开始归并，即先归
归并排序 以及面试题
我思故我在
10-22 174
归并排序时间复杂度：O（N*logN） 解法1：递归 思路：递归拆分每次分成两个，分到不能再分，分别排序有序然后再合并 /** * 归并排序 * @param arr */ public static void mergeSort1(int[] arr ){ //判断 是否需要排序 if(arr.length<2){ return; } proess(arr,0,arr.length-1); } /** * 递归分左右并且合并 * @para
数据结构——栈的实现（java实现）与相应的oj题
最新发布
2301_77993957的博客
07-17 798
2. 后缀表达式先进栈的是左操作数，后进栈的是右操作数，当我们需要出栈时，第一次获取栈顶元素是右操作数，第二次获取栈顶元素才是左操作数。实现思想：遍历字符串，遇到左括号则存入栈中，遇到右括号则与栈顶元素比较，相匹配，则继续循环，如果不匹配或栈为空，则返回false。栈也是一种线性表，栈只允许在表的一端进行插入与删除操作，所以栈中数据的特征的先进后出（先进来的后出去）。，获取两个操作数进行计算（需要注意的是第一次出栈的是右操作数，第二次出栈的是左操作数）
归并排序的相关面试题
学代码的咸鱼的博客
04-02 282
归并排序的面试题：小和问题，逆序对，大于2倍，区间上的个数
2.1 归并排序及其相关面试题
qq_22783587的博客
03-09 153
1. 归并排序 分治思想，分成两个数组，不断分，直到分不了为止， 合并，直到所有的分数组合并完成 递归写法 public void sort(int[] arr) { if (L == R) { return; } } private void process(int[] arr; int L, int R) { if (L == R) { return; } int mid = L + ((R - L) >> 1); process(arr, L, mid); p
（程序员面试题）归并排序
12-10 657
归并排序是效率仅次于快速排序的一种稳定排序，缺点是需要一块额外的空间用来存放需要处理的数据，具体代码如下： #include void merge(int num[], int start, int middle, int end) { int tmp1[10], tmp2[10]; int i, j, cur, len1, len2; int pos1, pos2;
《JAVA面试题》--数据结构（链表、队列、栈、二叉树、哈希表等）以及一些常用的算法排序：归并、快速排序、基数排序等.zip
04-02
十余年JAVA从业经验，精通JAVA技术体系，有志于做JAVA技能提升的朋友可与我联系，交个朋友 十余年JAVA从业经验，精通JAVA技术体系，有志于做JAVA技能提升的朋友可与我联系，交个朋友 十余年JAVA从业经验，精通JAVA...
百度：部分算法面试题1
08-08
【标题】：“部分算法面试题1” 【描述】：该文主要探讨了在算法面试中常见的几种问题，包括从大规模数据中随机抽样、选择排序中的元素以及在限制内存条件下找到最常见的查询词。 【部分内容】涉及到的知识点： 1...
面试题：排序算法
03-27 631
排序
今天会是有Offer的一天么：面试时你真的会写归并排序么
12-21
例如，在LeetCode第23题“Merge k Sorted Lists”中，就要求合并多个已排序的链表，归并排序的思想可以很自然地应用于这个问题，通过不断地合并两个最小的链表，直到所有链表合并成一个。 总结来说，归并排序的核心...
归并排序+面试题
F的博客
09-21 416
归并排序 1）整体是递归，左边排好序+右边排好序+merge让整体有序 2）让其整体有序的过程里用了排外序方法 3）利用master公式来求解时间复杂度 4）当然可以用非递归实现 归并排序复杂度 T(N) = 2*T(N/2) + O(N^1) 根据master可知时间复杂度为O(N*logN) merge过程需要辅助数组，所以额外空间复杂度为O(N) 归并排序的实质是把比较行为变成了有序信息并传递，比O(N^2)的排序快 代码实现 package com.lzf2.class03; /** *
归并排序-面试题2
我思故我在
10-22 106
问题： 在一个数组中， 任何一个前面的数a，和任何一个后面的数b， 如果(a,b)是降序的，就称为逆序对 返回数组中所有的逆序对 思路 1 就是在a后面比a小的数有多少个 2 归并排序合并的时候，从大到小 1 如果左边的大，就算 右边有多少比他小的 p2-m 个累加，然后左边-1位继续比下一个 2 如果左边的小，就右边-1 继续比较 代码 package class04; public class Code03_ReversePair { p...
可以借助归并排序秒杀的面试题！
Java笔记虾
03-28 233
归并排序是面试的高频考点，下面我们来一起看看如何借助归并排序解决逆序对，翻转对问题。在 leetcode 上面属于困难题目。大家做题之前可以顺便解决一下这个题目，leetcode 912 ...
2019年各个BET单位的归并排序面试题+面试经验
WangY.H
05-25 764
【1】微软2010年笔试题 在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序数对。 一个排列中逆序的总数就称为这个排列的逆序数。如{2，4，3，1}中，2和1，4和3，4和1，3和1是逆序数对，因此 整个数组的逆序数对个数为4，现在给定一数组，要求统计出该数组的逆序数对个数。计算数列的逆序数对个数最简 单的方便就最从前向后依次统计每个数字与它后面的数...
程序员面试题精选--归并排序
hoctor_ln的专栏
10-23 1726
采用分治策略 一般有三个步骤： 1、分解：将n个元素分成各含n/2个元素的子序列 2、解决：用合并排序法对两个子序列递归的排序 3、合并：合并两个已排序的子序列以得到排序结果。 在归并排序时，其长度为1时递归结束。单个元素被视为是已排序好的。 参考代码如下： #include using namespace std; #define MAX 0x7FFFFFFF //最大可
程序员面试经典题--归并排序
陀罗地
11-12 477
归并排序是一个只会出现在面试中的神奇存在。该算法的时间复杂度无论是在最好情况下还是在最坏的情况下，都是O(n log 2n )，空间复杂度为O(n)，是一种稳定的排序方法，其性能在待排序的记录较多时能得到充分的发挥。
算法16：LeetCode_归并排序_相关面试题 （超难）
街头小瘪三的专栏
02-08 705
假设初始序列含义n个记录，则可以看成是n个有序子序列，每个序列的长度为1，然后两两归并，得到【n/2】([x]表示不小于x的最小整数)个长度为2或1的有序咨询；1. 普通两层遍历肯定是可以解出这道题的，但是两层遍历的时间的复杂度是O(N^2). 而归并排序的时间复杂度是 N*logN， 性能上更优。思考： 面试题一是最小和，假设数组为 {5,2,3,4,1}，而你使用降序，猜猜得到的最小和会是多少？在一个数组中，一个数左边比它小的数的总和，叫数的小和，所有数的小和累加起来，叫数组小和。
归并排序讲解+相关面试题
Amxrjgcs的博客
05-08 592
代码实现(java) 包含递归和非递归 public class MergeSort { public static void main(String[] args) { int[] arr = new int[] {4,1,2,5,7,2,1,7,9,3}; for (int i : arr) { System.out.print(i + " "); } mergeSort2(arr); Sys
面试常问算法：快速排序与归并排序解析
"面试算法题及排序算法解析" 在面试中，算法题是评估候选人编程能力的重要部分。以下是一些常见的算法问题以及其中的一种排序算法——快速排序的实现细节。 1. **寻找单链表倒数第k个节点** 在单链表中找到倒数第...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值