AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

程序员代码面试指南之归并排序笔记02

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

一、归并排序

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)都是这么来的。


文章标签：
程序员
关键词：
程序员面试
面试代码
面试程序员
代码面试
面试笔记
鹿茸
目录
相关文章
热爱技术的小郑
|
4月前
|
Java 编译器 C++
【Java基础面试一】、为什么Java代码可以实现一次编写、到处运行？
这篇文章解释了Java能够实现“一次编写，到处运行”的原因，主要归功于Java虚拟机（JVM），它能够在不同平台上将Java源代码编译成的字节码转换成对应平台的机器码，实现跨平台运行。
热爱技术的小郑
92 3
【Java基础面试一】、为什么Java代码可以实现一次编写、到处运行？
程序员小海绵
|
3月前
|
设计模式 Java 关系型数据库
【Java笔记+踩坑汇总】Java基础+JavaWeb+SSM+SpringBoot+SpringCloud+瑞吉外卖/谷粒商城/学成在线+设计模式+面试题汇总+性能调优/架构设计+源码解析
本文是“Java学习路线”专栏的导航文章，目标是为Java初学者和初中高级工程师提供一套完整的Java学习路线。
程序员小海绵
497 37
程序员小海绵
|
3月前
|
存储 Java 关系型数据库
学成在线笔记+踩坑（0）——面试问题
介绍你的项目、项目难点、表是怎么设计的？、断点续传是怎么做的?、如何保证任务不重复执行? 、任务幂等性如何保证、分布式锁的三种实现方式
程序员小海绵
124 1
学成在线笔记+踩坑（0）——面试问题
小王老师呀
|
3月前
|
算法 程序员 Go
PHP 程序员学会了 Go 语言就能唬住面试官吗？
【9月更文挑战第8天】学会Go语言可提升PHP程序员的面试印象，但不足以 solely “唬住” 面试官。学习新语言能展现学习能力、拓宽技术视野，并增加就业机会。然而，实际项目经验、深入理解语言特性和综合能力更为关键。全面展示这些方面才能真正提升面试成功率。
小王老师呀
63 10
服务端技术栈
|
4月前
|
存储 缓存 Java
面试问Spring循环依赖？今天通过代码调试让你记住
该文章讨论了Spring框架中循环依赖的概念，并通过代码示例帮助读者理解这一概念。
服务端技术栈
60 5
面试问Spring循环依赖？今天通过代码调试让你记住
DreamCoders
|
4月前
|
JavaScript 前端开发 小程序
CoderGuide 程序员前后端面试题库，打造全网最高质量题库
CoderGuide涵盖范围包括且不限于：前端面试题(Vue，React，JS，HTTP，HTML，CSS面试题等)，后端面试题(Java，Python，Golang，PHP，Linux，Mysql面试题等)，以及算法面试题，大厂面试题，高频面试题，校招面试题等，你想要的，这里都有！
DreamCoders
76 2
游客ot6eft3qn37ga
|
4月前
|
JavaScript 前端开发 程序员
JS小白请看！一招让你的面试成功率大大提高——规范代码
JS小白请看！一招让你的面试成功率大大提高——规范代码
游客ot6eft3qn37ga
50 5
hnrk7epeorhrk
|
6月前
|
前端开发 应用服务中间件 程序员
老程序员分享：Nginx相关面试题
老程序员分享：Nginx相关面试题
hnrk7epeorhrk
66 2
热爱技术的小郑
|
4月前
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输，之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。
热爱技术的小郑
60 2
程序员皮皮林
|
1月前
|
存储 缓存 算法
面试官：单核 CPU 支持 Java 多线程吗？为什么？被问懵了！
本文介绍了多线程环境下的几个关键概念，包括时间片、超线程、上下文切换及其影响因素，以及线程调度的两种方式——抢占式调度和协同式调度。文章还讨论了减少上下文切换次数以提高多线程程序效率的方法，如无锁并发编程、使用CAS算法等，并提出了合理的线程数量配置策略，以平衡CPU利用率和线程切换开销。
程序员皮皮林
74 1
面试官：单核 CPU 支持 Java 多线程吗？为什么？被问懵了！

热门文章

最新文章

  • 1
    京东面试：聊聊Spring事务？Spring事务的10种失效场景？加入型传播和嵌套型传播有什么区别？
  • 2
    Java社招面试题：& 和 && 的区别，HR的套路险些让我翻车！
  • 3
    字节面试：聊聊 CAP 定理？哪些中间件是AP？ 哪些是CP？ 说说 为什么？
  • 4
    MySQL进阶突击系列(03) MySQL架构原理solo九魂17环连问 | 给大厂面试官的一封信
  • 5
    面试的系统设计题，给我整懵了。。。
  • 6
    只会“有序无序”？面试官嫌弃的List、Set、Map回答！
  • 7
    阿里面试：聊聊 CAP 定理？哪些中间件是AP？为什么？
  • 8
    Spring面试必问：手写Spring IoC 循环依赖底层源码剖析
  • 9
    面试官刁钻提问？轻松应对 break、continue 和 return 的巧妙用法
  • 10
    面试官的加分题：super关键字全解析，轻松应对！
  • 1
    【JavaEE】——单例模式引起的多线程安全问题：“饿汉/懒汉”模式，及解决思路和方法（面试高频）
    8
  • 2
    【JavaEE】——线程“饿死问题” wait && notify（面试高频）
    9
  • 3
    面试必问的多线程优化技巧与实战
    29
  • 4
    最新版 | SpringBoot3如何自定义starter（面试常考）
    12
  • 5
    最新版 | 深入剖析SpringBoot3源码——分析自动装配原理（面试常考）
    25
  • 6
    面试的流程，面试的重点
    48
  • 7
    用好PDCA循环法，轻松slay面试
    13
  • 8
    面试官必问的分布式锁面试题，你答得上来吗？
    14
  • 9
    HashMap高频面试题，让你掌握青铜回答与王者级回答，你值得拥有
    14
  • 10
    MySQL进阶突击系列(03) MySQL架构原理solo九魂17环连问 | 给大厂面试官的一封信
    56

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • 你的第一门C语言课
  • Java编程入门
  • 天池leetcode编程基础课

    • 相关电子书

    更多
  • 阿里云技术面试红宝书
  • 超全算法笔试-模拟题精解合集
  • 程序员面试宝典
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)