备案控制台
探索云世界
开发者社区 人工智能 文章 正文

算法之归并排序

2023-10-12 14
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 一、归并排序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)都是这么来的。


文章标签：
算法
关键词：
算法归并排序
鹿茸
目录
相关文章
桃李春风一杯酒
|
5月前
|
搜索推荐 算法 Python
如何实现归并排序算法？ 要求：编写一个Python函数，输入一个无序列表，返回排序后的列表。
如何实现归并排序算法？ 要求：编写一个Python函数，输入一个无序列表，返回排序后的列表。
桃李春风一杯酒
27 2
阿辉不一般
|
20天前
|
搜索推荐 C语言 C++
【排序算法】C语言实现归并排序，包括递归和迭代两个版本
【排序算法】C语言实现归并排序，包括递归和迭代两个版本
阿辉不一般
11 1
ForcibleBugMaker
|
22天前
|
存储 算法 搜索推荐
【数据结构与算法】归并排序（详解：递归与非递归的归并排序 | 赠：冒泡排序和选择排序）
【数据结构与算法】归并排序（详解：递归与非递归的归并排序 | 赠：冒泡排序和选择排序）
ForcibleBugMaker
24 0
修修修也
|
2月前
|
搜索推荐 算法
【数据结构】八大排序之归并排序算法
【数据结构】八大排序之归并排序算法
修修修也
21 5
我是夜阑的狗
|
2月前
|
机器学习/深度学习 算法 搜索推荐
数据结构与算法（Java篇）笔记--归并排序
数据结构与算法（Java篇）笔记--归并排序
我是夜阑的狗
24 0
桃李春风一杯酒
|
2月前
|
搜索推荐 算法 Python
python实现归并排序算法。
【2月更文挑战第9天】【2月更文挑战第24篇】python实现归并排序算法。
桃李春风一杯酒
17 2
xxxhuxxx
|
3月前
|
存储 搜索推荐 算法
【数据结构排序算法篇】----归并排序【实战演练】
【数据结构排序算法篇】----归并排序【实战演练】
xxxhuxxx
28 0
醋溜马桶圈
|
3月前
|
搜索推荐
排序算法之七：归并排序（非递归）
排序算法之七：归并排序（非递归）
醋溜马桶圈
26 1
排序算法之七：归并排序（非递归）
唐唐思
|
3月前
|
搜索推荐 C++
【非递归版】归并排序算法（2）
【非递归版】归并排序算法（2）
唐唐思
20 0
唐唐思
|
3月前
|
搜索推荐 算法 C++
【递归版】归并排序算法（1）
【递归版】归并排序算法（1）
唐唐思
22 0

热门文章

最新文章

  • 1
    【MATLAB】GA_ELM神经网络时序预测算法
  • 2
    使用Python实现DBSCAN聚类算法
  • 3
    R语言聚类算法的应用实例
  • 4
    Machine Learning机器学习之决策树算法 Decision Tree（附Python代码）
  • 5
    普林斯顿算法讲义（二）（4）
  • 6
    52个AIGC视频生成算法模型介绍（上）
  • 7
    【算法与数据结构】队列的实现详解
  • 8
    深度解析JVM世界：垃圾判断和垃圾回收算法
  • 9
    普林斯顿算法讲义（一）（4）
  • 10
    R语言贝叶斯MCMC：GLM逻辑回归、Rstan线性回归、Metropolis Hastings与Gibbs采样算法实例
  • 1
    MVVM模型，虚拟DOM和diff算法
    125
  • 2
    Opencv（C++）学习系列---Laplacian拉普拉斯边缘检测算法
    22
  • 3
    Opencv(C++)学习系列---Canny边缘检测算法
    22
  • 4
    使用python实现FP-Growth算法
    29
  • 5
    关于Dijkstra算法
    12
  • 6
    基于yolov2深度学习网络的视频手部检测算法matlab仿真
    27
  • 7
    Python基础算法解析：支持向量机（SVM）
    35
  • 8
    探索数据结构在算法优化中的关键作用
    35
  • 9
    视觉智能平台常见问题之算法私有化部署交付给公司内部运行如何解决
    25
  • 10
    视觉智能平台常见问题之其他算法定制化开发如何解决
    29

    • 相关课程

    更多
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

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

    • 相关实验场景

    更多
  • TLS1.3的后量子算法集成
  • RSA非对称加密算法
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考