Java岗大厂面试百日冲刺 - 日积月累，每日三题【Day23】—— 算法1(2)

空间复杂度

快速排序是一种原地排序，只需要一个很小的栈作为辅助空间，空间复杂度为O(log2n)，所以适合在数据集比较大的时候使用。

时间复杂度

时间复杂度比较复杂，最好的情况是O(n)，最差的情况是O(n2)，所以平时说的O(nlogn)，为其平均时间复杂度。

• O(n)：理想的情况，每次划分所选择的中间数恰好将当前序列几乎等分，经过log2n趟划分，便可得到长度为1的子表。这样，整个算法的时间复杂度为O(nlog2n)。

• O(n2)：最坏的情况，每次所选的中间数是当前序列中的最大或最小元素，这使得每次划分所得的子表中一个为空表，另一子表的长度为原表的长度-1。这样，长度为n的数据表的快速排序需要经过n趟划分，使得整个排序算法的时间复杂度为O(n2)。

追问2：说一下快排的算法原理

---

算法步骤

1. 选定一个基准数（一般取第一位数字）作为中心点（Pivot）；

2. 将大于Pivot的数字放到Pivot的左边；

3. 将小于Pivot的数字放到Pivot的右边；

4. 第一次排序结束后，分别对左右子序列继续递归重复前三步操作，直到左右子序列长度只有单个元素为止。

demo示例

实例数组：arr[] = {19，97，9，17，1，8}；

1. 取出基准数Pivot，以该值为中心轴。

快速排序中的规则：右边有坑，就从左边Arr[L + n]取值来填，反之左边有坑，则从右边Arr[R - n]取值来填；

2. 从左边取的基准值，左边的Arr[L]就空出来了，则先从右侧取值来填，从最右侧下标开始，在Arr[R] 取到第一个值“8”；

3. 将取到的Arr[R]与基准值比较，发现小于基准值，则插入到Arr[R]，占到了基准值Pivot的位置上。

4. 然后从Arr[L+1]的位置取出值，继续向右匹配并排序，将匹配到的值（匹配规则如下）插入到右侧Arr[R]的空位置上；

匹配规则：大于基准值的插入到Arr[R]，如果小于，则直接忽略并跳过，继续向右取值，直到坐标L和坐标R重合。

5. 发现取出的值大于Pivot（基准值），则将其插入到Arr[R]。

6. 左边有坑，从右边Arr[R-1]继续匹配，Arr[R-1] = 1，小于基准值，则插入到Arr[L]的坑中；

7. 右边有坑了，继续从左边取值继续匹配，则取到Arr[L+1] = 9,小于基准值，则忽略并跳过，继续找Arr[L + 1]继续匹配。

8. 继续从左边坐标 + 1 取值继续匹配，则取到Arr[L] = 17，又小于基准值，则忽略并跳过，继续找Arr[L + 1]继续匹配。

9. 最后L坐标和R坐标重合了，将Pivot基准值填入

10. 至此，快速排序第一轮完整流程结束，分出了左右子序列，左边都是小于Pivot基准值的，右边都是大于Pivot基准值的。

11. 继续对左、右子序列递归进行处理，一直缩小到左、右都是一个值，则快速排序结束，最终得出顺序数组{1,8,9,17,19,97}；中间递归流程这里不再赘述。

追问2：来吧！给我手敲一个快排

---

package com.softsec.demo;

/**

• Created with IDEA

• @Author Chensj

• @Date 2020/5/17 19:04

• @Description

• @Version 1.0

*/

public class quickSortDemo {

public static void main(String[] args) {

// 创建测试数组

int[] arr = new int[]{19,97,9,17,1,8};

System.out.println(“排序前：”);

showArray(arr); // 打印数组

// 调用快排接口

quickSort(arr);

System.out.println(“\n” + “排序后：”);

showArray(arr);// 打印数组

}

/**

• 快速排序

• @param array

*/

public static void quickSort(int[] array) {

int len;

if(array == null

|| (len = array.length) == 0

|| len == 1) {

return ;

}

sort(array, 0, len - 1);

}

/**

• 快排核心算法，递归实现

• @param array

• @param left

• @param right

*/

public static void sort(int[] array, int left, int right) {

if(left > right) {

return;

}

// base中存放基准数

int base = array[left];

int i = left, j = right;

while(i != j) {

// 顺序很重要，先从右边开始往左找，直到找到比base值小的数

while(array[j] >= base && i < j) {

j–;

}

// 再从左往右边找，直到找到比base值大的数

while(array[i] <= base && i < j) {

i++;

}

// 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置

if(i < j) {

int tmp = array[i];

array[i] = array[j];

array[j] = tmp;

}

}

// 将基准数放到中间的位置（基准数归位）

array[left] = array[i];

array[i] = base;

// 递归，继续向基准的左右两边执行和上面同样的操作

// i的索引处为上面已确定好的基准值的位置，无需再处理

sort(array, left, i - 1);

sort(array, i + 1, right);

}

/**

• 数组打印

• @param num

*/

private static void showArray(int[] num) {

for (int i = 0; i < num.length; i++) {

System.out.print(num[i] + " ");

}

}

}

---

坐标：深圳

作者：對你何止一句钟意

---

面试题2：来！再给我手撸一个Spring

===================================================================================

我：？？？

追问1：哦，咳咳…说一下构成递归的前提条件有啥？

---

函数内部调用的自身函数的编程技巧称为递归（recursion）。

构成递归的条件：

1. 子问题须与原始问题为同样的事，且更为简单；

2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。

追问2：递归都有哪些优缺点？

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：

---

函数内部调用的自身函数的编程技巧称为递归（recursion）。

构成递归的条件：

1. 子问题须与原始问题为同样的事，且更为简单；

2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。

追问2：递归都有哪些优缺点？

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：
[外链图片转存中…(img-ZQmMOS5j-1714362332081)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录