【Hello Algorithm】归并排序及其面试题(下)

简介: 【Hello Algorithm】归并排序及其面试题(下)

归并排序算法题

小和问题

题目要求我们计算数组的小和 完整的题目和示例如下

该题目出自于牛客网编程题 – 数组的小和

做这道题目最笨的方法就是多次遍历整个数组 每次找当前位置的小和 很显然这样子做的时间复杂度是N的平方 使用这种解法在面试的过程中是没有分数的!

所以我们必须要想出一个更加优秀的解法出来 实际上我们可以利用归并排序每两个数只比较一次的特点来解决

首先我们回答下下面这个问题

找出数组中所有的小和 是不是等价于将数组从左到右的比较一遍找出小于数字出现的次数啊

如果说一个数字在比较的时候小于另外一个数字 我们就叫它小于数字

比如说数组中只有两个元素3和4 在比较的时候我们即可以说有一个数字3也可以说3出现了一次 最后得到的结果是等价的

而我们使用归并排序的过程就是这个从左到右比较的过程

代码运行如下

#include <iostream>
using namespace std;
#include <vector>
long long Merge(vector<int>& nums , int left , int mid , int right)
{
    vector<int> temp(right-left+1, 0);
    int i = left;
    int j = mid + 1;
    int k = 0;
    long long SUM = 0;
    while(i <= mid && j <= right)
    {
        if (nums[i] <= nums[j])
        {
            // small sum
            SUM += (right - j + 1) * nums[i];
            temp[k] = nums[i];
            i++;
        }
        else
        {
            temp[k] = nums[j];
            j++;
        }
        k++;
    }
    while(i <= mid)
    {
        temp[k++] = nums[i++];
    }
    while(j <= right)
    {
        temp[k++] = nums[j++];
    }
    for (i = left ; i <= right ; i++)
    {
        nums[i] = temp[i - left];
    }
    return SUM;
}
long long SmallNums(vector<int>& nums , int left , int right)
{
    if (left >= right)
    {
        return 0;
    }
    int mid = left + (right - left) / 2; 
    return 
    SmallNums(nums, left, mid)
    +
    SmallNums(nums, mid + 1, right)
    +
    Merge(nums,  left, mid,  right);
}
int main() 
{
    long n = 0;
    cin >> n;
    vector<int> nums(n , 0);
    for (int i = 0; i < n ; i++)
    {
        cin >> nums[i];
    }
    long long sum = SmallNums(nums, 0, n-1);
    cout << sum;
    return 0;
}

我们可以发现 实际上这段代码对比归并排序只多出了一行代码

  • 一行代码
SUM += (right - j + 1) * nums[i];

这就是计算小和的步骤了

运行结果如下

翻转对问题

让你计算一个数组中的翻转对 题目和示例出现在lc493题

值得我们注意的是 该翻转对的下标必须要是左下标小于右下标 也就是说该翻转对必须要按照从左到右的顺序 并且只比较一遍 这里我们就应该想到使用我们的归并排序了

但是题目中的要求并不是单纯的大于小于 而是一个大于两倍的关系

这其实就是这道题目相比较于其他考查归并排序题目的一个难点 解决方案是这样子的

我们首先找出符合题目要求的数据 最后再进行归并排序

使用这个思路去解决问题就好了

也就是说归并之前我们先用一段代码来找到答案 代码表示如下

int MergeAndFind(vector<int>& nums , int left , int mid , int right)
    {
        int ans = 0;
        int windowr = mid + 1; 
        for (int i = left ; i <= mid ; i++)
        {
            while(windowr <= right && nums[i] > (long)(nums[windowr] << 1))
            {
                windowr++;
            }
            ans += windowr - mid - 1;
        }
        vector<int> help(right - left + 1 , 0);
        int i = left;
        int j = mid + 1;
        int k = 0;
        while(i <= mid && j <= right)
        {
            if (nums[i] <= nums[j])
            {
                help[k] = nums[i];
                i++;
            }
            else 
            {
                help[k] = nums[j];
                j++;
            }
            k++;
        }
        while(i <= mid)
        {
            help[k++] = nums[i++];
        }
        while (j <= right)
        {
            help[k++] = nums[j++];
        }
        for (i = left ; i <= right ; i++)
        {
            nums[i] = help[i - left];
        }
        return ans;
    }

剩下的代码就是单纯的归并排序了 没有什么好讲解的 完整代码如下

class Solution {
public:
    int MergeAndFind(vector<int>& nums , int left , int mid , int right)
    {
        int ans = 0;
        int windowr = mid + 1; 
        for (int i = left ; i <= mid ; i++)
        {
            while(windowr <= right && (long long)nums[i] >((long long)nums[windowr] * 2))
            {
                windowr++;
            }
            ans += windowr - mid - 1;ii
        }
        vector<int> help(right - left + 1 , 0);
        int i = left;
        int j = mid + 1;
        int k = 0;
        while(i <= mid && j <= right)
        {
            if (nums[i] <= nums[j])
            {
                help[k] = nums[i];
                i++;
            }
            else 
            {
                help[k] = nums[j];
                j++;
            }
            k++;
        }
        while(i <= mid)
        {
            help[k++] = nums[i++];
        }
        while (j <= right)
        {
            help[k++] = nums[j++];
        }
        for (i = left ; i <= right ; i++)
        {
            nums[i] = help[i - left];
        }
        return ans;
    }
    int _reversPairs(vector<int>& nums , int left , int right)
    {
        if (left >= right)
        {
            return 0;
        }
        int mid = left + (right - left) / 2;
        return 
        _reversPairs(nums , left , mid)
        +
        _reversPairs(nums , mid + 1 , right)
        +
        MergeAndFind(nums , left , mid , right); 
    }
    int reversePairs(vector<int>& nums) 
    {
       return  _reversPairs(nums , 0 , nums.size() -1);
    }
};

这道题目注意的有两点

  • 我们乘2必须要使用 “ * ” 运算符 不能使用位运算 否则负数就有可能出问题
  • 在进行乘法的时候要进行类型转换 不然可能会有数据溢出的问题

以上就是归并排序的写法以及归并排序思想可以解决的一些面试题

相关文章
|
算法 搜索推荐
【Hello Algorithm】归并排序及其面试题(上)
【Hello Algorithm】归并排序及其面试题
55 0
|
5月前
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输,之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。
|
2月前
|
存储 缓存 算法
面试官:单核 CPU 支持 Java 多线程吗?为什么?被问懵了!
本文介绍了多线程环境下的几个关键概念,包括时间片、超线程、上下文切换及其影响因素,以及线程调度的两种方式——抢占式调度和协同式调度。文章还讨论了减少上下文切换次数以提高多线程程序效率的方法,如无锁并发编程、使用CAS算法等,并提出了合理的线程数量配置策略,以平衡CPU利用率和线程切换开销。
面试官:单核 CPU 支持 Java 多线程吗?为什么?被问懵了!
|
2月前
|
存储 算法 Java
大厂面试高频:什么是自旋锁?Java 实现自旋锁的原理?
本文详解自旋锁的概念、优缺点、使用场景及Java实现。关注【mikechen的互联网架构】,10年+BAT架构经验倾囊相授。
大厂面试高频:什么是自旋锁?Java 实现自旋锁的原理?
|
2月前
|
存储 缓存 Java
大厂面试必看!Java基本数据类型和包装类的那些坑
本文介绍了Java中的基本数据类型和包装类,包括整数类型、浮点数类型、字符类型和布尔类型。详细讲解了每种类型的特性和应用场景,并探讨了包装类的引入原因、装箱与拆箱机制以及缓存机制。最后总结了面试中常见的相关考点,帮助读者更好地理解和应对面试中的问题。
84 4
|
3月前
|
算法 Java 数据中心
探讨面试常见问题雪花算法、时钟回拨问题,java中优雅的实现方式
【10月更文挑战第2天】在大数据量系统中,分布式ID生成是一个关键问题。为了保证在分布式环境下生成的ID唯一、有序且高效,业界提出了多种解决方案,其中雪花算法(Snowflake Algorithm)是一种广泛应用的分布式ID生成算法。本文将详细介绍雪花算法的原理、实现及其处理时钟回拨问题的方法,并提供Java代码示例。
123 2
|
3月前
|
JSON 安全 前端开发
第二次面试总结 - 宏汉科技 - Java后端开发
本文是作者对宏汉科技Java后端开发岗位的第二次面试总结,面试结果不理想,主要原因是Java基础知识掌握不牢固,文章详细列出了面试中被问到的技术问题及答案,包括字符串相关函数、抽象类与接口的区别、Java创建线程池的方式、回调函数、函数式接口、反射以及Java中的集合等。
45 0
|
5月前
|
XML 存储 JSON
【IO面试题 六】、 除了Java自带的序列化之外,你还了解哪些序列化工具?
除了Java自带的序列化,常见的序列化工具还包括JSON(如jackson、gson、fastjson)、Protobuf、Thrift和Avro,各具特点,适用于不同的应用场景和性能需求。
|
5月前
|
Java
【Java基础面试三十七】、说一说Java的异常机制
这篇文章介绍了Java异常机制的三个主要方面:异常处理(使用try、catch、finally语句)、抛出异常(使用throw和throws关键字)、以及异常跟踪栈(异常传播和程序终止时的栈信息输出)。

热门文章

最新文章