AI 助理
备案控制台
开发者社区 人工智能 文章 正文

算法之归并排序

2023-10-12 23
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 一、归并排序1）整体是递归，左边排好序+右边排好序+merge让整体有序2）让其整体有序的过程里用了排外序方法3）利用master公式来求解时间复杂度4）当然可以用非递归实现

一、归并排序

1）整体是递归，左边排好序+右边排好序+merge让整体有序

2）让其整体有序的过程里用了排外序方法

3）利用master公式来求解时间复杂度

4）当然可以用非递归实现

public class Code01_MergeSort {
  public static void merge(int[] arr, int L, int M, int R) {
    int[] help = new int[R - L + 1];
    int i = 0;
    int p1 = L;
    int p2 = M + 1;
    while (p1 <= M && p2 <= R) {
      help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
    }
    while (p1 <= M) {
      help[i++] = arr[p1++];
    }
    while (p2 <= R) {
      help[i++] = arr[p2++];
    }
    for (i = 0; i < help.length; i++) {
      arr[L + i] = help[i];
    }
  }
  // 递归方法实现
  public static void mergeSort1(int[] arr) {
    if (arr == null || arr.length < 2) {
      return;
    }
    process(arr, 0, arr.length - 1);
  }
  //arr[L...R]范围上，变成有序的
  public static void process(int[] arr, int L, int R) {
    if (L == R) {
      return;
    }
    int mid = L + ((R - L) >> 1);
    process(arr, L, mid);
    process(arr, mid + 1, R);
    merge(arr, L, mid, R);
  }
  // 非递归方法实现
  public static void mergeSort2(int[] arr) {
    if (arr == null || arr.length < 2) {
      return;
    }
    int N = arr.length;
    int mergeSize = 1;//当前有序的，左组长度
    while (mergeSize < N) {
      int L = 0;
      while (L < N) {
        int M = L + mergeSize - 1;
        if (M >= N) {
          break;
        }
        int R = Math.min(M + mergeSize, N - 1);
        merge(arr, L, M, R);
        L = R + 1;
      }
      if (mergeSize > N / 2) {
        break;
      }
      mergeSize <<= 1;
    }
  }
  // for test
  public static int[] generateRandomArray(int maxSize, int maxValue) {
    int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
    for (int i = 0; i < arr.length; i++) {
      arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
    }
    return arr;
  }
  // for test
  public static int[] copyArray(int[] arr) {
    if (arr == null) {
      return null;
    }
    int[] res = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
      res[i] = arr[i];
    }
    return res;
  }
  // for test
  public static boolean isEqual(int[] arr1, int[] arr2) {
    if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
      return false;
    }
    if (arr1 == null && arr2 == null) {
      return true;
    }
    if (arr1.length != arr2.length) {
      return false;
    }
    for (int i = 0; i < arr1.length; i++) {
      if (arr1[i] != arr2[i]) {
        return false;
      }
    }
    return true;
  }
  // for test
  public static void printArray(int[] arr) {
    if (arr == null) {
      return;
    }
    for (int i = 0; i < arr.length; i++) {
      System.out.print(arr[i] + " ");
    }
    System.out.println();
  }
  // for test
  public static void main(String[] args) {
    int testTime = 500000;
    int maxSize = 100;
    int maxValue = 100;
    boolean succeed = true;
    for (int i = 0; i < testTime; i++) {
      int[] arr1 = generateRandomArray(maxSize, maxValue);
      int[] arr2 = copyArray(arr1);
      mergeSort1(arr1);
      mergeSort2(arr2);
      if (!isEqual(arr1, arr2)) {
        succeed = false;
        printArray(arr1);
        printArray(arr2);
        break;
      }
    }
    System.out.println(succeed ? "Nice!" : "Oops!");
  }
}



二、归并排序复杂度

T(N) = 2*T(N/2) + O(N^1)

根据master可知时间复杂度为O(N*logN)

merge过程需要辅助数组，所以额外空间复杂度为O(N)

归并排序的实质是把比较行为变成了有序信息并传递，比O(N^2)的排序快


三、用常见面试题再深入理解一下归并排序的精髓

在一个数组中，一个数左边比它小的数的总和，叫数的小和，所有数的小和累加起来，叫数组小和。求数组小和。

例子： [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

public class Code02_SmallSum {
  public static int smallSum(int[] arr) {
    if (arr == null || arr.length < 2) {
      return 0;
    }
    return process(arr, 0, arr.length - 1);
  }
  // arr[L..R]既要排好序，也要求小和返回
  public static int process(int[] arr, int l, int r) {
    if (l == r) {
      return 0;
    }
    int mid = l + ((r - l) >> 1);
    return 
        process(arr, l, mid) 
        + 
        process(arr, mid + 1, r) 
        + 
        merge(arr, l, mid, r);
  }
  public static int merge(int[] arr, int L, int m, int r) {
    int[] help = new int[r - L + 1];//辅助数组
    int i = 0;
    int p1 = L;
    int p2 = m + 1;
    int res = 0;
    while (p1 <= m && p2 <= r) {
      res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
      help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
    }
    //要么P1越界了，要么P2越界了
    while (p1 <= m) {
      help[i++] = arr[p1++];
    }
    while (p2 <= r) {
      help[i++] = arr[p2++];
    }
    for (i = 0; i < help.length; i++) {
      arr[L + i] = help[i];
    }
    return res;
  }
  // for test
  public static int comparator(int[] arr) {
    if (arr == null || arr.length < 2) {
      return 0;
    }
    int res = 0;
    for (int i = 1; i < arr.length; i++) {
      for (int j = 0; j < i; j++) {
        res += arr[j] < arr[i] ? arr[j] : 0;
      }
    }
    return res;
  }
  // for test
  public static int[] generateRandomArray(int maxSize, int maxValue) {
    int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
    for (int i = 0; i < arr.length; i++) {
      arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
    }
    return arr;
  }
  // for test
  public static int[] copyArray(int[] arr) {
    if (arr == null) {
      return null;
    }
    int[] res = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
      res[i] = arr[i];
    }
    return res;
  }
  // for test
  public static boolean isEqual(int[] arr1, int[] arr2) {
    if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
      return false;
    }
    if (arr1 == null && arr2 == null) {
      return true;
    }
    if (arr1.length != arr2.length) {
      return false;
    }
    for (int i = 0; i < arr1.length; i++) {
      if (arr1[i] != arr2[i]) {
        return false;
      }
    }
    return true;
  }
  // for test
  public static void printArray(int[] arr) {
    if (arr == null) {
      return;
    }
    for (int i = 0; i < arr.length; i++) {
      System.out.print(arr[i] + " ");
    }
    System.out.println();
  }
  // for test
  public static void main(String[] args) {
    int testTime = 500000;
    int maxSize = 100;
    int maxValue = 100;
    boolean succeed = true;
    for (int i = 0; i < testTime; i++) {
      int[] arr1 = generateRandomArray(maxSize, maxValue);
      int[] arr2 = copyArray(arr1);
      if (smallSum(arr1) != comparator(arr2)) {
        succeed = false;
        printArray(arr1);
        printArray(arr2);
        break;
      }
    }
    System.out.println(succeed ? "Nice!" : "Fucking fucked!");
  }
}

四、快速排序

1、Partition过程

给定一个数组arr，和一个整数num。请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。

要求额外空间复杂度O(1)，时间复杂度O(N)


2、荷兰国旗问题

给定一个数组arr，和一个整数num。请把小于num的数放在数组的左边，等于num的数放在中间，大于num的数放在数组的右边。

要求额外空间复杂度O(1)，时间复杂度O(N)



3、快速排序1.0

在arr[L..R]范围上，进行快速排序的过程：

1）用arr[R]对该范围做partition，<= arr[R]的数在左部分并且保证arr[R]最后来到左部分的最后一个位置，记为M； <= arr[R]的数在右部分（arr[M+1..R]）

2）对arr[L..M-1]进行快速排序(递归)

3）对arr[M+1..R]进行快速排序(递归)

因为每一次partition都会搞定一个数的位置且不会再变动，所以排序能完成


4、快速排序2.0

在arr[L..R]范围上，进行快速排序的过程：

1）用arr[R]对该范围做partition，< arr[R]的数在左部分，== arr[R]的数中间，>arr[R]的数在右部分。假设== arr[R]的数所在范围是[a,b]

2）对arr[L..a-1]进行快速排序(递归)

3）对arr[b+1..R]进行快速排序(递归)

因为每一次partition都会搞定一批数的位置且不会再变动，所以排序能完成


5、快速排序1.0和2.0的时间复杂度分析

数组已经有序的时候就是复杂度最高的时候

时间复杂度O(N^2)


6、快速排序3.0(随机快排+荷兰国旗技巧优化)

在arr[L..R]范围上，进行快速排序的过程：

1）在这个范围上，随机选一个数记为num，

1）用num对该范围做partition，< num的数在左部分，== num的数中间，>num的数在右部分。假设== num的数所在范围是[a,b]

2）对arr[L..a-1]进行快速排序(递归)

3）对arr[b+1..R]进行快速排序(递归)

因为每一次partition都会搞定一批数的位置且不会再变动，所以排序能完成

public class Code03_PartitionAndQuickSort {
  public static void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
  }
  public static int partition(int[] arr, int L, int R) {
    if (L > R) {
      return -1;
    }
    if (L == R) {
      return L;
    }
    int lessEqual = L - 1;
    int index = L;
    while (index < R) {
      if (arr[index] <= arr[R]) {
        swap(arr, index, ++lessEqual);
      }
      index++;
    }
    swap(arr, ++lessEqual, R);
    return lessEqual;
  }
  //arr[L...R]玩荷兰国旗问题的划分，以arr[R]做划分值
  //  < arr[R]  ==arr[R]   >arr[R]
  public static int[] netherlandsFlag(int[] arr, int L, int R) {
    if (L > R) {
      return new int[] { -1, -1 };
    }
    if (L == R) {
      return new int[] { L, R };
    }
    int less = L - 1; //   <区域 右边界
    int more = R;//   > 区域 左边界
    int index = L;
    while (index < more) {
      if (arr[index] == arr[R]) {
        index++;
      } else if (arr[index] < arr[R]) {
        swap(arr, index++, ++less);
      } else {
        swap(arr, index, --more);
      }
    }
    swap(arr, more, R);
    return new int[] { less + 1, more };
  }
  //快速排序1.0
  public static void quickSort1(int[] arr) {
    if (arr == null || arr.length < 2) {
      return;
    }
    process1(arr, 0, arr.length - 1);
  }
  //L...R Partition arr[R]   [ <=arr[R]   arr[R]   >arr[R] ]
  public static void process1(int[] arr, int L, int R) {
    if (L >= R) {
      return;
    }
    int M = partition(arr, L, R);
    process1(arr, L, M - 1);
    process1(arr, M + 1, R);
  }
  //快速排序2.0
  public static void quickSort2(int[] arr) {
    if (arr == null || arr.length < 2) {
      return;
    }
    process2(arr, 0, arr.length - 1);
  }
  public static void process2(int[] arr, int L, int R) {
    if (L >= R) {
      return;
    }
    int[] equalArea = netherlandsFlag(arr, L, R);
    process1(arr, L, equalArea[0] - 1);
    process1(arr, equalArea[1] + 1, R);
  }
  //快速排序3.0
  public static void quickSort3(int[] arr) {
    if (arr == null || arr.length < 2) {
      return;
    }
    process3(arr, 0, arr.length - 1);
  }
  public static void process3(int[] arr, int L, int R) {
    if (L >= R) {
      return;
    }
    swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
    int[] equalArea = netherlandsFlag(arr, L, R);
    process1(arr, L, equalArea[0] - 1);
    process1(arr, equalArea[1] + 1, R);
  }
  // for test
  public static int[] generateRandomArray(int maxSize, int maxValue) {
    int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
    for (int i = 0; i < arr.length; i++) {
      arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
    }
    return arr;
  }
  // for test
  public static int[] copyArray(int[] arr) {
    if (arr == null) {
      return null;
    }
    int[] res = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
      res[i] = arr[i];
    }
    return res;
  }
  // for test
  public static boolean isEqual(int[] arr1, int[] arr2) {
    if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
      return false;
    }
    if (arr1 == null && arr2 == null) {
      return true;
    }
    if (arr1.length != arr2.length) {
      return false;
    }
    for (int i = 0; i < arr1.length; i++) {
      if (arr1[i] != arr2[i]) {
        return false;
      }
    }
    return true;
  }
  // for test
  public static void printArray(int[] arr) {
    if (arr == null) {
      return;
    }
    for (int i = 0; i < arr.length; i++) {
      System.out.print(arr[i] + " ");
    }
    System.out.println();
  }
  // for test
  public static void main(String[] args) {
    int testTime = 500000;
    int maxSize = 100;
    int maxValue = 100;
    boolean succeed = true;
    for (int i = 0; i < testTime; i++) {
      int[] arr1 = generateRandomArray(maxSize, maxValue);
      int[] arr2 = copyArray(arr1);
      int[] arr3 = copyArray(arr1);
      quickSort1(arr1);
      quickSort2(arr2);
      quickSort3(arr3);
      if (!isEqual(arr1, arr2) || !isEqual(arr2, arr3)) {
        succeed = false;
        break;
      }
    }
    System.out.println(succeed ? "Nice!" : "Oops!");
  }
}



五、随机快排的时间复杂度分析

1）通过分析知道，划分值越靠近中间，性能越好；越靠近两边，性能越差

2）随机选一个数进行划分的目的就是让好情况和差情况都变成概率事件

3）把每一种情况都列出来，会有每种情况下的时间复杂度，但概率都是1/N

4）那么所有情况都考虑，时间复杂度就是这种概率模型下的长期期望！

时间复杂度O(N*logN)，额外空间复杂度O(logN)都是这么来的。


文章标签：
算法
关键词：
算法归并排序
鹿茸
目录
相关文章
java冯坚持
|
1月前
|
算法 搜索推荐 Shell
数据结构与算法学习十二：希尔排序、快速排序（递归、好理解）、归并排序（递归、难理解）
这篇文章介绍了希尔排序、快速排序和归并排序三种排序算法的基本概念、实现思路、代码实现及其测试结果。
java冯坚持
21 1
加油，旭杏
|
5月前
|
机器学习/深度学习 算法 搜索推荐
【初阶算法4】——归并排序的详解，及其归并排序的扩展
【初阶算法4】——归并排序的详解，及其归并排序的扩展
加油，旭杏
41 0
【初阶算法4】——归并排序的详解，及其归并排序的扩展
努力学习的小廉
|
1月前
|
存储 搜索推荐 算法
【排序算法（二）】——冒泡排序、快速排序和归并排序—＞深层解析
【排序算法（二）】——冒泡排序、快速排序和归并排序—＞深层解析
努力学习的小廉
16 0
龙大吉
|
1月前
|
存储 算法 搜索推荐
算法进阶之路：Python 归并排序深度剖析，让数据排序变得艺术起来！
算法进阶之路：Python 归并排序深度剖析，让数据排序变得艺术起来！
龙大吉
72 0
糜终
|
1月前
|
搜索推荐 Java Go
深入了解归并排序算法
深入了解归并排序算法
糜终
20 0
小华qvq
|
6月前
|
算法 前端开发 搜索推荐
前端算法之归并排序
前端算法之归并排序
小华qvq
38 0
软件求生
|
3月前
|
算法 搜索推荐 Java
算法实战：手写归并排序，让复杂排序变简单！
归并排序是一种基于“分治法”的经典算法，通过递归分割和合并数组，实现O(n log n)的高效排序。本文将通过Java手写代码，详细讲解归并排序的原理及实现，帮助你快速掌握这一实用算法。
软件求生
42 0
土木林森
|
3月前
|
数据采集 搜索推荐 算法
【高手进阶】Java排序算法：从零到精通——揭秘冒泡、快速、归并排序的原理与实战应用，让你的代码效率飙升！
【8月更文挑战第21天】Java排序算法是编程基础的重要部分，在算法设计与分析及实际开发中不可或缺。本文介绍内部排序算法，包括简单的冒泡排序及其逐步优化至高效的快速排序和稳定的归并排序，并提供了每种算法的Java实现示例。此外，还探讨了排序算法在电子商务、搜索引擎和数据分析等领域的广泛应用，帮助读者更好地理解和应用这些算法。
土木林森
42 0
龙大吉
|
4月前
|
存储 算法 搜索推荐
算法进阶之路：Python 归并排序深度剖析，让数据排序变得艺术起来！
【7月更文挑战第12天】归并排序是高效稳定的排序算法，采用分治策略。Python 实现包括递归地分割数组及合并已排序部分。示例代码展示了如何将 `[12, 11, 13, 5, 6]` 分割并归并成有序数组 `[5, 6, 11, 12, 13]`。虽然 $O(n log n)$ 时间复杂度优秀，但需额外空间，适合大规模数据排序。对于小规模数据，可考虑其他算法。**
龙大吉
76 4
百锦再@新空间代码工作室
|
4月前
|
算法 搜索推荐 C#
算法——归并排序
算法——归并排序
百锦再@新空间代码工作室
33 2

热门文章

最新文章

  • 1
    【数据结构与算法】一篇文章彻底搞懂二分查找（思路图解+代码优化）两种实现方式，递归与非递归
  • 2
    算法学习之顺序结构
  • 3
    泛型KMP算法
  • 4
    OneMob（一体传媒）：大数据算法 让营销更精准
  • 5
    【算法】算法之美—Fire Net
  • 6
    Node.js使用jsrsasign实现SHA256withRSA加密算法
  • 7
    【编程练习】收集的一些c++代码片，算法排序，读文件，写日志，快速求积分等等
  • 8
    字符串相似度算法 递归与动态规划求解分析
  • 9
    【算法研究】Bresenham画线算法
  • 10
    算法导论第十四章 数据结构的扩张
  • 1
    算法：位运算
    37
  • 2
    算法：双指针
    52
  • 3
    基于harris角点和RANSAC算法的图像拼接matlab仿真
    91
  • 4
    m基于遗传优化的LDPC码NMS译码算法最优归一化参数计算和误码率matlab仿真
    76
  • 5
    深入浅出JVM（十三）之垃圾回收算法细节
    53
  • 6
    深入浅出JVM（十二）之垃圾回收算法
    44
  • 7
    常见的算法排序（2）
    46
  • 8
    数据结构与算法 动态规划(启发式搜索、遗传算法、强化学习待完善)
    98
  • 9
    数据结构与算法 回溯
    36
  • 10
    数据结构与算法 分治
    39

    • 相关课程

    更多
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • 数据+算法定义新世界
  • 袋鼠云基于实时计算的反黄牛算法
  • Alink：基于Apache Flink的算法平台

    • 相关实验场景

    更多
  • 使用Swing算法实现商品推荐
  • RSA密码算法设计与实现
  • 欧拉图的构造性证明与算法实现
  • 推荐系统入门之使用ALS算法实现打分预测
    • 下一篇
    阿里云OSS设置跨域访问