您现在的位置是:首页 >技术教程 >Java排序网站首页技术教程
Java排序
Java排序
大家好,我是晓星航。今天为大家带来的是 Java排序 相关内容的讲解!😀
🐾1. 概念🐾
1.1 排序
排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。
平时的上下文中,如果提到排序,通常指的是排升序(非降序)。
通常意义上的排序,都是指的原地排序(in place sort)。
1.2 稳定性(重要)
两个相等的数据,如果经过排序后,排序算法能保证其相对位置不发生变化,则我们称该算法是具备稳定性的排序算法。
1.3 应用
- 各大商城的价格从低到高等
- 中国大学排名
💐2. 七大基于比较的排序比-总览💐
简历上这么写:熟悉常见的排序算法:如:快速排序,堆排序,归并排序
🌸3. 插入排序🌸
3.1 直接插入排序-原理
整个区间被分为
- 有序区间
- 无序区间
每次选择无序区间的第一个元素,在有序区间内选择合适的位置插入
3.2 实现
取出array[i]给tmp,如果前面>后面则后面赋值为前面的值,直到前面<后面,将tmp直接给前面完成插入排序。
/**
* 时间复杂度:O(N^2)
* 最好的情况时O(N):对于直接插入排序来说,最好的情况就是数据有序时
* 根据这个结论,推导出另一个结论:对于直接插入排序来说,数据越有序,越快。
* 空间复杂度:O(1)
* 稳定性:稳定的
* 一个稳定的排序,可以实现为不稳定的排序
* 但是一个本身就不稳定的排序,是不能变为稳定的排序
* 经常使用在 数据量不多 且 整体数据 趋于有序了
* @param array
*/
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int tmp = array[i];
int j = i - 1;
for (; j >= 0 ; j--) {
if (array[j] > tmp) {
array[j + 1] = array[j];
} else {
//array[j + 1] = tmp; 只要j回退的时候,遇到了 比tmp小的元素就结束这次的比较
break;
}
}
//j回退到了 小于0 的地方
//第一次的j = -1; 之后的j值与上面if什么时候break有关
array[j + 1] = tmp;
}
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,4};
insertSort(array);
System.out.println(Arrays.toString(array));
}
3.3 性能分析
稳定性:稳定
插入排序,初始数据越接近有序,时间效率越高。
/**
* 有序的数据
* @param capacity
*/
public static void test1(int capacity) {
int[] array = new int[capacity];
for (int i = 0; i < array.length; i++) {
array[i] = i;
}
long start = System.currentTimeMillis();
insertSort(array);
// shellSort(array);
// selectSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
/**
* 无序的数据
* @param capacity
*/
public static void test2(int capacity) {
int[] array = new int[capacity];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(capacity);
}
long start = System.currentTimeMillis();
insertSort(array);
// shellSort(array);
// selectSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void main(String[] args) {
test1(10_0000);
test2(10_0000);
}
由上图可知插入排序排10万个有序数据和无序数据所需的时间分别为0和1779。
3.4 折半插入排序(了解)
在有序区间选择数据应该插入的位置时,因为区间的有序性,可以利用折半查找的思想。
public static void bsInsertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int v = array[i];
int left = 0;
int right = i;
// [left, right)
// 需要考虑稳定性
while (left < right) {
int m = (left + right) / 2;
if (v >= array[m]) {
left = m + 1;
} else {
right = m;
}
}
// 搬移
for (int j = i; j > left; j--) {
array[j] = array[j - 1];
}
array[left] = v;
}
}
🌷4. 希尔排序🌷
4.1 原理
思考:假设 现在有10000个数据 如果对这组数据进行排序,使用插入排序 10000个数据 * 10000 = 1 0000 0000 ->1个亿
若采取100组 100 * 100 = 10000 分组的思想,我们会发现 时间复杂度会有一个很大的改变
希尔排序法又称缩小增量法。希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成个组,所有距离为的记录分在同一组内,并对每一组内的记录进行排序。然后,取,重复上述分组和排序的工作。当到达=1时,所有记录在统一组内排好序。
- 希尔排序是对直接插入排序的优化。【即先分组–>(变有序)再排序】
- 当gap > 1时都是预排序,目的是让数组更接近于有序。当gap == 1时,数组已经接近有序的了,这样就会很快。这样整体而言,可以达到优化的效果。我们实现后可以进行性能测试的对比。
上述分组为正常分组
如果按照跳跃式分组 我们 则能将更多的更小的数放到前面,上述图为按五组来分。
上述图为按照3组来跳跃式分组并进行排序。
4.2 实现
/**
*
* @param array 待排序序列
* @param gap 数组
*/
public static void shell(int[] array, int gap) {
for (int i = gap; i < array.length; i++) {
int tmp = array[i];
int j = i - gap;
for (; j >= 0; j-=gap) {
if (array[j] > tmp) {
array[j + gap] = array[j];
} else {
break;
}
}
array[j + gap] = tmp;
}
}
/**
* 时间复杂度[和增量有关系]:O(n^1.3 - n^1.5)
* 空间复杂度:O(1)
* 稳定性:不稳定的
* 看在比较的过程中 是否发生了跳跃式的交换 如果发生了跳跃式的交换 那么就是不稳定的排序
* 基本上没有考过
* @param array
*/
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 1) {
shell(array,gap);
gap /= 2;
}
shell(array,1);//保证最后是一组
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,4,23,14,25,42,2,7};
shellSort(array);
System.out.println(Arrays.toString(array));
}
4.3 性能分析
时间复杂度:O(n^1.3 - n^1.5)
稳定性:不稳定
/**
* 有序的数据
* @param capacity
*/
public static void test1(int capacity) {
int[] array = new int[capacity];
for (int i = 0; i < array.length; i++) {
array[i] = i;
}
long start = System.currentTimeMillis();
// insertSort(array);
shellSort(array);
// selectSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
/**
* 无序的数据
* @param capacity
*/
public static void test2(int capacity) {
int[] array = new int[capacity];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(capacity);
}
long start = System.currentTimeMillis();
// insertSort(array);
shellSort(array);
// selectSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void main(String[] args) {
test1(10_0000);
test2(10_0000);
}
由上图可知希尔排序排10万个有序数据和无序数据所需的时间分别为0和16。
因此希尔排序的时间效率大大优于插入排序!!!
🍀5. 选择排序🍀
5.1 直接选择排序-原理
每一次从无序区间选出最大(或最小)的一个元素,存放在无序区间的最后(或最前),直到全部待排序的数据元素排完 。
每次都拿一个元素与后面元素依次比较,如果后面元素更小(更大)则交换,否则不变。
5.2 实现
public static void swap(int[] array,int i,int j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
/**
* 选择排序
* 时间复杂度:O(N^2)
* 空间复杂度:O(1)
* 稳定性:不稳定的排序
* @param array 待排序的序列
*/
public static void selectSort(int[] array) {
for (int i = 0; i < array.length; i++) {
int minIndex = i;
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
}
swap(array,i,minIndex);
}
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,4,23,14,25,42,2,7};
selectSort(array);
System.out.println(Arrays.toString(array));
}
5.3 性能分析
稳定性:不稳定
int[] a = { 9, 2, 5a, 7, 4, 3, 6, 5b };
// 交换中该情况无法识别,保证 5a 还在 5b 前边
/**
* 有序的数据
* @param capacity
*/
public static void test1(int capacity) {
int[] array = new int[capacity];
for (int i = 0; i < array.length; i++) {
array[i] = i;
}
long start = System.currentTimeMillis();
// insertSort(array);
// shellSort(array);
selectSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
/**
* 无序的数据
* @param capacity
*/
public static void test2(int capacity) {
int[] array = new int[capacity];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(capacity);
}
long start = System.currentTimeMillis();
// insertSort(array);
// shellSort(array);
selectSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void main(String[] args) {
test1(10_0000);
test2(10_0000);
}
由上图可知选择排序排10万个有序数据和无序数据所需的时间分别为705和2914,数据的有序和无序对时间的消耗并不是那么明显。
5.4 双向选择排序(了解)
每一次从无序区间选出最小 + 最大的元素,存放在无序区间的最前和最后,直到全部待排序的数据元素排完 。
public static void selectSortOP
(int[] array) {
int low = 0;
int high = array.length - 1;
// [low, high] 表示整个无序区间
// 无序区间内只有一个数也可以停止排序了
while (low <= high) {
int min = low;
int max = low;
for (int i = low + 1; i <= max; i++) {
if (array[i] < array[min]) {
min = i;
}
if (array[i] > array[max]) {
max = i;
}
}
swap(array, min, low);
// 见下面例子讲解
if (max == low) {
max = min;
}
swap(array, max, high);
}
}
private void swap(int[] array, int i, int j) {
int t = array[i];
array[i] = array[j];
array[j] = t;
}
array = { 9, 5, 2, 7, 3, 6, 8 }; // 交换之前
// low = 0; high = 6
// max = 0; min = 2
array = { 2, 5, 9, 7, 3, 6, 8 }; // 将最小的交换到无序区间的最开始后
// max = 0,但实际上最大的数已经不在 0 位置,而是被交换到 min 即 2 位置了
// 所以需要让 max = min 即 max = 2
array = { 2, 5, 8, 7, 3, 6, 9 }; // 将最大的交换到无序区间的最结尾后
🌻6. 堆排序🌻
6.1 原理
基本原理也是选择排序,只是不在使用遍历的方式查找无序区间的最大的数,而是通过堆来选择无序区间的最大的数。
注意: 排升序要建大堆;排降序要建小堆。
6.2 实现
/**
*时间复杂度:O(N * log N)
* 空间复杂度:O(1)
* 稳定性:不稳定
* @param array
*/
public static void heapSort(int[] array) {
//1/建堆O(N)
createHeap(array);
int end = array.length - 1;
//2、交换然后调整 O(N * log N)
while (end > 0) {
swap(array,0,end);
shiftDown(array,0,end);
end--;
}
}
public static void createHeap(int[] array) {
for (int parent = (array.length-1-1)/2; parent >= 0; parent--) {
shiftDown(array,parent,array.length);
}
}
public static void shiftDown(int[] array,int parent,int len) {
int child = parent * 2 + 1;//左孩子下标
while (child < len) {
if (child + 1 < len && array[child] < array[child + 1]) {
child++;
}
//child下标 就是左右孩子最大值的下标
if (array[parent] < array[child]) {
swap(array,parent,child);
parent = child;
child = parent * 2 + 1;
} else {
break;
}
}
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7};
heapSort(array);
System.out.println(Arrays.toString(array));
}
6.3 性能分析
稳定性:不稳定
/**
* 有序的数据
* @param capacity
*/
public static void test1(int capacity) {
int[] array = new int[capacity];
for (int i = 0; i < array.length; i++) {
array[i] = i;
}
long start = System.currentTimeMillis();
// insertSort(array);
// shellSort(array);
// selectSort(array);
heapSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
/**
* 无序的数据
* @param capacity
*/
public static void test2(int capacity) {
int[] array = new int[capacity];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(capacity);
}
long start = System.currentTimeMillis();
// insertSort(array);
// shellSort(array);
// selectSort(array);
heapSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void main(String[] args) {
test1(10_0000);
test2(10_0000);
}
由上图可知堆排序排10万个有序数据和无序数据所需的时间分别为17和15。
🍂7. 冒泡排序🍂
7.1 原理
在无序区间,通过相邻数的比较,将最大的数冒泡到无序区间的最后,持续这个过程,直到数组整体有序
7.2 实现
/**
* 冒泡排序
* 时间复杂度:O(N^2) 这个代码 不管是好是坏 都是O(N^2)
* 空间复杂度:O(1)
* 稳定性:稳定的排序
* @param array
*/
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 -i; j++) {
if (array[j] > array[j + 1]) {
swap(array,j,j + 1);
}
}
}
}
/**
* 冒泡排序
* 时间复杂度:O(N^2)
* 有序情况下:O(n)
* 空间复杂度:O(1)
* 稳定性:稳定的排序
* @param array
*/
public static void bubbleSort2(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
boolean flg = false;
for (int j = 0; j < array.length - 1 -i; j++) {
if (array[j] > array[j + 1]) {
swap(array,j,j + 1);
flg = true;
}
}
if (flg == false) {
break;
}
}
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
bubbleSort2(array);
System.out.println(Arrays.toString(array));
}
7.3 性能分析
稳定性:稳定
/**
* 有序的数据
* @param capacity
*/
public static void test1(int capacity) {
int[] array = new int[capacity];
for (int i = 0; i < array.length; i++) {
array[i] = i;
}
long start = System.currentTimeMillis();
// insertSort(array);
// shellSort(array);
// selectSort(array);
// heapSort(array);
bubbleSort(array);
// bubbleSort2(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
/**
* 无序的数据
* @param capacity
*/
public static void test2(int capacity) {
int[] array = new int[capacity];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(capacity);
}
long start = System.currentTimeMillis();
// insertSort(array);
// shellSort(array);
// selectSort(array);
// heapSort(array);
bubbleSort(array);
// bubbleSort2(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void main(String[] args) {
test1(10_0000);
test2(10_0000);
}
由上图可知普通冒泡排序排10万个有序数据和无序数据所需的时间分别为976和12488。
由上图可知加入了判断逻辑的冒泡排序排10万个有序数据和无序数据所需的时间分别为0和12418。
🍄8. 快速排序(重要)🍄
8.1 原理-总览
- 从待排序区间选择一个数,作为基准值(pivot);
- Partition: 遍历整个待排序区间,将比基准值小的(可以包含相等的)放到基准值的左边,将比基准值大的(可以包含相等的)放到基准值的右边;
- 采用分治思想,对左右两个小区间按照同样的方式处理,直到小区间的长度 == 1,代表已经有序,或者小区间的长度 == 0,代表没有数据。
先把start的值放入tmp,end 找比 tmp小的放入空的地方(小的放入数组前面)再看start找,然后start 找比 tmp大的放入空(大的放到数组后面)的地方再看end找,直到end和start相遇,我们将tmp放入空的位置进行下一次循环。
实现:
/**
* 时间复杂度:
* 最好:【每次可以均匀分割待排序序列】O(N*log n)
* 最坏:数据有序 或者逆序的情况 O(N^2)
* 空间复杂度:
* 最好:O(log n)
* 最坏:O(n) 单分支的一棵树
* 稳定性:不稳定
* @param array 待排序的数组
*/
//这里的quickSrot函数是为了接口一致而设立的
public static void quickSort(int[] array) {
quick(array,0,array.length-1);
}
public static void quick(int[] array,int left,int right) {
if (left >= right) {
return;
}
int pivot = partition(array,left,right);//基准
quick(array,left,pivot - 1);//递归左边
quick(array,pivot + 1,right);//递归右边
}
private static int partition(int[] array,int start,int end) {
int tmp = array[start];
while (start < end) {
while (start < end && array[end] >= tmp) {
end--;
}
//end下标就遇到了小于tmp的值
array[start] = array[end];
while (start < end && array[start] <= tmp) {
start++;
}
//start下标就遇到了大于tmp的值
array[end] = array[start];
}
array[start] = tmp;
return start;
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
quickSort(array);
System.out.println(Arrays.toString(array));
}
8.2 原理-partition(随机取基准)
Hoare 法:
随机取基准法:有可能每次随机的数据,作为基准的时候,也会出现单分支的情况。(随机十分靠运气)
实现:
private static int partition(int[] array, int left, int right) {
int i = left;
int j = right;
int pivot = array[left];
while (i < j) {
while (i < j && array[j] >= pivot) {
j--;
}
while (i < j && array[i] <= pivot) {
i++;
}
swap(array, i, j);
}
swap(array, i, left);
return i;
}
挖坑法:
基本思路和Hoare 法一致,只是不再进行交换,而是进行赋值(填坑+挖坑)
实现:
private static int partition(int[] array,int start,int end) {
int tmp = array[start];
while (start < end) {
while (start < end && array[end] >= tmp) {
end--;
}
//end下标就遇到了小于tmp的值
array[start] = array[end];
while (start < end && array[start] <= tmp) {
start++;
}
//start下标就遇到了大于tmp的值
array[end] = array[start];
}
array[start] = tmp;
return start;
}
前后遍历法:
private static int partition(int[] array, int left, int right) {
int d = left + 1;
int pivot = array[left];
for (int i = left + 1; i <= right; i++) {
if (array[i] < pivot) {
swap(array, i, d);
d++;
}
}
swap(array, d, left);
return d;
}
8.3 性能分析
稳定性:不稳定
8.4 原理-基准值的选择(三数取中法)
- 选择边上(左或者右)
- 随机选择
- 几数取中(例如三数取中):array[left], array[mid], array[right] 大小是中间的为基准值
以三数取中法我们树的分支就不会出现单分支的情况。
/**
* 时间复杂度:
* 最好:【每次可以均匀分割待排序序列】O(N*log n)
* 最坏:数据有序 或者逆序的情况 O(N^2)
* 空间复杂度:
* 最好:O(log n)
* 最坏:O(n) 单分支的一棵树
* 稳定性:不稳定
* @param array 待排序的数组
*/
public static void quickSort(int[] array) {
quick(array,0,array.length-1);
}
public static void quick(int[] array,int left,int right) {
if (left >= right) {
return;
}
int minValIndex = findMidValIndex(array,left,right);
swap(array,minValIndex,left);
int pivot = partition(array,left,right,minValIndex);//基准
quick(array,left,pivot - 1);//递归左边
quick(array,pivot + 1,right);//递归右边
}
public static int findMidValIndex(int[] array,int start,int end) {
int mid = start + ((end - start) >>> 1);
if (array[start] < array[start]) {
if (array[mid] < array[start]) {
return start;
} else if (array[mid] > array[end]) {
return end;
} else {
return mid;
}
} else {
if (array[mid] > array[start]) {
return start;
} else if (array[mid] < array[end]) {
return end;
} else {
return mid;
}
}
}
private static int partition(int[] array,int start,int end,int minValIndex) {
int tmp = array[minValIndex];
while (start < end) {
while (start < end && array[end] >= tmp) {
end--;
}
//end下标就遇到了小于tmp的值
array[start] = array[end];
while (start < end && array[start] <= tmp) {
start++;
}
//start下标就遇到了大于tmp的值
array[end] = array[start];
}
array[start] = tmp;
return start;
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
quickSort(array);
System.out.println(Arrays.toString(array));
}
8.5 原理-非递归分支
import java.util.*;
private static int partition(int[] array,int start,int end) {
int tmp = array[start];
while (start < end) {
while (start < end && array[end] >= tmp) {
end--;
}
//end下标就遇到了小于tmp的值
array[start] = array[end];
while (start < end && array[start] <= tmp) {
start++;
}
//start下标就遇到了大于tmp的值
array[end] = array[start];
}
array[start] = tmp;
return start;
}
public static void quickSort(int[] array) {
Stack<Integer> stack = new Stack<>();
int left = 0;
int right = array.length - 1;
int pivot = partition(array,left,right);
if (pivot > left + 1) {
//左边有2个元素
stack.push(left);
stack.push(pivot - 1);
}
if (pivot < right - 1) {
//右边有2个元素
stack.push(pivot + 1);
stack.push(right);
}
while (!stack.isEmpty()) {
right = stack.pop();
left = stack.pop();
pivot = partition(array,left,right);
if (pivot > left + 1) {
//左边有2个元素
stack.push(left);
stack.push(pivot - 1);
}
if (pivot < right - 1) {
//右边有2个元素
stack.push(pivot + 1);
stack.push(right);
}
}
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
quickSort(array);
System.out.println(Arrays.toString(array));
}
8.6 优化总结
- 选择基准值很重要,通常使用几数取中法
- partition 过程中把和基准值相等的数也选择出来
- 待排序区间小于一个阈值时(例如 48),使用直接插入排序
8.7 总结
-
在待排序区间选择一个基准值
-
- 选择左边或者右边
- 随机选取
- 几数取中法
-
做 partition,使得小的数在左,大的数在右
-
- hoare
- 挖坑
- 前后遍历
- 将基准值相等的也选择出来(了解)
-
分治处理左右两个小区间,直到小区间数目小于一个阈值,使用插入排序
🌵9. 归并排序(重要)🌵
9.1 原理-总览
归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide andConquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
9.2 原理-合并两个有序数组
例如int[] array1 = [1,6,7,10];和int[] array2 = [2,3,4,9];
/**
* @param array1 有序的
* @param array2 有序的
* @return 合成之后的数组
*/
public static int[] mergeArray(int[] array1,int[] array2) {
//注意判断参数
int[] tmp = new int[array1.length + array2.length];
int s1 = 0;
int e1 = array1.length - 1;
int s2 = 0;
int e2 = array2.length - 1;
int i = 0;
while (s1 <= e1 && s2 <= e2) {
if (array1[s1] <= array2[s2]) {
tmp[i++] = array1[s1++];
} else {
tmp[i++] = array2[s2++];
}
}
while (s1 <= e1) {
tmp[i++] = array1[s1++];
}
while (s2 <= e2) {
tmp[i++] = array2[s2++];
}
return tmp;
}
public static void main(String[] args) {
int[] array1 = {1,7,11,12,15,19};
int[] array2 = {1,2,7,7,11,13,14,17,18};
int[] regular = mergeArray(array1,array2);
System.out.println(Arrays.toString(regular));
}
9.3 实现
/**
* 归并排序
* 时间复杂度:O(N * log N)
* 空间复杂度:O(N)
* 稳定性:稳定
* 如果 array[s1] <= array[s2] 不取等号 那么就是不稳定的排序
*
* 学过的排序只有三个是稳定的:
* 冒泡 插入 归并
* @param array
*/
public static void mergeSort(int[] array) {
mergeSortInternal(array,0,array.length - 1);
}
private static void mergeSortInternal(int[] array,int low,int high) {
if (low >= high) {
return;
}
//int mid = (low + high) >>> 1;
int mid = low + ((high - low) >>> 1);
//左边
mergeSortInternal(array,low,mid);
//右边
mergeSortInternal(array,mid + 1,high);
//归并
merge(array,low,mid,high);
}
public static void merge(int[] array,int low,int mid,int high) {
int[] tmp = new int[high - low + 1];
int s1 = low;
int e1 = mid;
int s2 = mid + 1;
int e2 = high;
int i = 0;
while (s1 <= e1 && s2 <= e2) {
if (array[s1] <= array[s2]) {
tmp[i++] = array[s1++];
} else {
tmp[i++] = array[s2++];
}
}
while (s1 <= e1) {
tmp[i++] = array[s1++];
}
while (s2 <= e2) {
tmp[i++] = array[s2++];
}
//拷贝tmp数组的元素 放到原来的数组array当中
for (int j = 0; j < i; j++) {
array[j + low] = tmp[j];
}
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
mergeSort(array);
System.out.println(Arrays.toString(array));
}
9.4 性能分析
稳定性:稳定
/**
* 有序的数据
* @param capacity
*/
public static void test1(int capacity) {
int[] array = new int[capacity];
for (int i = 0; i < array.length; i++) {
array[i] = i;
}
long start = System.currentTimeMillis();
// insertSort(array);
// shellSort(array);
// selectSort(array);
// heapSort(array);
// bubbleSort(array);
// bubbleSort2(array);
// quickSort(array);
mergeSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
/**
* 无序的数据
* @param capacity
*/
public static void test2(int capacity) {
int[] array = new int[capacity];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(capacity);
}
long start = System.currentTimeMillis();
// insertSort(array);
// shellSort(array);
// selectSort(array);
// heapSort(array);
// bubbleSort(array);
// bubbleSort2(array);
// quickSort(array);
mergeSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void main(String[] args) {
test1(10_0000);
test2(10_0000);
}
由上图可知归并排序排10万个有序数据和无序数据所需的时间分别为9和13。
9.5 优化总结
在排序过程中重复利用两个数组,减少元素的复制过程
9.6 非递归版本
public static void merge(int[] array,int low,int mid,int high) {
int[] tmp = new int[high - low + 1];
int s1 = low;
int e1 = mid;
int s2 = mid + 1;
int e2 = high;
int i = 0;
while (s1 <= e1 && s2 <= e2) {
if (array[s1] <= array[s2]) {
tmp[i++] = array[s1++];
} else {
tmp[i++] = array[s2++];
}
}
while (s1 <= e1) {
tmp[i++] = array[s1++];
}
while (s2 <= e2) {
tmp[i++] = array[s2++];
}
//拷贝tmp数组的元素 放到原来的数组array当中
for (int j = 0; j < i; j++) {
array[j + low] = tmp[j];
}
}
/**
* 非递归实现归并排序
*
* @param array
*/
public static void mergeSort(int[] array) {
int nums = 1;//每组的数据个数
while (nums < array.length) {
//数组每次都要进行遍历
for (int i = 0; i < array.length; i += nums*2) {
int left = i;
int mid = left + nums - 1;
if (mid >= array.length) {
mid = array.length - 1;
}
int right = mid + nums;
if (right >= array.length) {
right = array.length - 1;
}
//小标确定之后,进行合并
merge(array,left,mid,right);
}
nums *= 2;
}
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
mergeSort(array);
System.out.println(Arrays.toString(array));
}
9.7 海量数据的排序问题
内部排序:排序过程需要在内存等内部存储进行的排序
外部排序:排序过程需要在磁盘等外部存储进行的排序
前提:内存只有 1G,需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下,所以需要外部排序(磁盘上排序),而归并排序是最常用的外部排序
- 先把文件切分成 200 份,每个 512 M
- 分别对 512 M 排序,因为内存已经可以放的下,所以任意排序方式都可以
- 进行 200 路归并,同时对 200 份有序文件做归并过程,最终结果就有序了
🌴10. 排序总结🌴
测试各大排序的时间代码:
/**
* 有序的数据
* @param capacity
*/
public static void test1(int capacity) {
int[] array = new int[capacity];
for (int i = 0; i < array.length; i++) {
array[i] = i;
}
long start = System.currentTimeMillis();
insertSort(array);
shellSort(array);
selectSort(array);
heapSort(array);
bubbleSort(array);
bubbleSort2(array);
quickSort(array);
mergeSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
/**
* 无序的数据
* @param capacity
*/
public static void test2(int capacity) {
int[] array = new int[capacity];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(capacity);
}
long start = System.currentTimeMillis();
insertSort(array);
shellSort(array);
selectSort(array);
heapSort(array);
bubbleSort(array);
bubbleSort2(array);
quickSort(array);
mergeSort(array);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void main7(String[] args) {
test1(10_0000);
test2(10_0000);
}
🌰11. 其他非基于比较的排序(了解)🌰
1、确定计数数组的大小
2、这个计数排序,适合用在 0-99 范围
a、求数组的最大值maxVal 最小是minVal
maxVal - minVal + 1 = 数组的长度
b、count[array[i]-minVal]
/**
* 计数牌序
* 时间复杂度:O(N)
* 空间复杂度:O(M)M:代表当前数据的范围:900-999
* 稳定性:当前代码是不稳定的,但是本质是稳定的
* 一般适用于 有n个数,数据范围是0-n之间的
* @param array
*/
public static void countingSort(int[] array) {
int maxVal = array[0];
int minVal = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] < minVal) {
minVal = array[i];
}
if (array[i] > maxVal) {
maxVal = array[i];
}
}
//说明已经找到了最大值和最小值
int[] count = new int[maxVal - minVal + 1];//默认都是0
//统计array数组当中,每个数据出现的次数 例如最大值为8 最小值为1 数组长度从1到8 即8-1+1 = 8
for (int i = 0; i < array.length; i++) {
int index = array[i];
//为了空间的合理使用 这里需要index-minVal 防止923-900
count[index - minVal]++;
}
//说明在计数数组当中,已经把array数组当中,每个数据出现的次数已经统计好了
//接下来,只需要,遍历计数数组,把数据写回array
int indexArray = 0;
for (int i = 0; i < count.length; i++) {
while (count[i] > 0) {
//这里一定要加minVal,因为不一定就是i出现了count[i]
array[indexArray] = i + minVal;
count[i]--;//拷贝一个之后,次数就少一个
indexArray++;//下标得向后移动
}
}
}
public static void main(String[] args) {
int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
countingSort(array);
System.out.println(Arrays.toString(array));
}
首先我们创建10个桶
按照他们的个位数对应的数字分别放入各个桶中
然后按照0~9的顺序将他们依次拿出来,这样他们的个位数就有顺序了
按照他们的十位数对应的数字分别放入各个桶中
然后按照0~9的顺序将他们依次拿出来,这样他们的个位数和十位数就都有顺序了
按照他们的百位数对应的数字分别放入各个桶中
然后按照0~9的顺序将他们依次拿出来,这样他们的个位数和十位数和百位数就都有顺序了
感谢各位读者的阅读,本文章有任何错误都可以在评论区发表你们的意见,我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞,你的每一次鼓励都是作者创作的动力哦!😘