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

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

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


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

热门文章

最新文章

  • 1
    面试必问的4种单点登录的实现方式，你知道几个？
  • 2
    面试官：你是如何评估一个线程池需要设置多少个线程
  • 3
    外企面试，哪有你想象的那么难!（已收埃森哲、NTTDATA等8家外企offer）
  • 4
    超有用的sql查询语句。项目、面试都有用
  • 5
    C# 面试题解析-请遍历页面上所有的TextBox控件并给它赋值为string.Empty
  • 6
    面试题1：赋值运算符函数
  • 7
    大厂高频面试真题详解：最长无重复字符的子串
  • 8
    vue基础面试题(day01)
  • 9
    15-大厂面试题-JVM垃圾回收采用的是什么算法，有什么区别和优劣？
  • 10
    java面试题(十三)之多线程篇
  • 1
    大厂高频面试题：ReentrantLock 与 synchronized异同点对比
    66
  • 2
    【Java多线程】面试常考 —— JUC(java.util.concurrent) 的常见类
    78
  • 3
    【Java多线程】面试常考——锁策略、synchronized的锁升级优化过程以及CAS（Compare and swap）
    64
  • 4
    【LeetCode力扣】面试题 17.14. 最小K个数（top-k问题）
    89
  • 5
    【刷题】 leetcode 面试题 08.05.递归乘法
    71
  • 6
    【刷题】 leetcode 面试题 01.06 字符串压缩
    66
  • 7
    MySQL第五战：常见面试题（下）
    60
  • 8
    MySQL第四战：视图以及常见面试题（上）
    60
  • 9
    面试高频 ThreadLocal类详解
    39
  • 10
    总结Spring Boot面试知识点
    67

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • 学生—职场人的进阶指南
  • 天池leetcode编程基础课
  • Java编程入门

    • 相关电子书

    更多
  • 阿里云技术面试红宝书
  • 超全算法笔试-模拟题精解合集
  • 程序员面试宝典
    • 下一篇
    无影云桌面