package com.example.test.test01;
import java.time.Duration;
import java.time.Instant;
import java.util.Arrays;
import java.util.Random;
/**
* 测试效率:归并排序、快速排序、希尔排序(移位法) > 插入排序 > 选择排序、冒泡排序
*/
public class Sort {
/** 冒泡排序:相邻两个数比较,每一轮将最大或最小的数排在最后,下一轮不用比较最后一个数 */
public static void bubbleSort(int[] arr) {
boolean flag = false;
int temp;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
flag = true;
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
if (!flag) {
// 在一趟排序中,一次交换都没有发生过
break;
}
// 重置flag, 进行下次判断
flag = false;
}
}
/** 选择排序:每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完 */
public static void selectSort(int[] arr) {
int temp;
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
}
/** 插入排序:从插入的地方向前扫描,找到相应位置并插入,把已排序元素逐步向后挪位,即认为前面的已经做了排序 */
public static void insertSort(int[] arr) {
int j;
int temp;
for (int i = 1; i < arr.length; i++) {
temp = arr[i];
// 因为前面的数已经做了排序,如果发现与前一个比较大小不成立,则该轮不用比较了,直接跳出
for (j = i; j > 0 && arr[j - 1] > temp; j--) {
arr[j] = arr[j - 1];
}
// 将需要插入的数放入这个位置,如果没有进入上面的循环比较,则i=j相当于赋值原来的值,就是值没变
arr[j] = temp;
}
}
/** 插入排序:从插入的地方向前扫描,找到相应位置并插入,把已排序元素逐步向后挪位,即认为前面的已经做了排序 */
public static void insertSort2(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
if (arr[j - 1] > arr[j]) {
int temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
}
}
/**
* 希尔排序(交换法),缩小增量的插入排序:设待排序元素序列有n个元素,首先取一个整数increment(小于n)作为间隔将全部元素分为increment个子序列,
* 所有距离为increment的元素放在同一个子序列中,在每一个子序列中分别实行直接插入排序。然后缩小间隔increment,
* 重复上述子序列划分和排序工作。直到最后取increment=1,将所有元素放在同一个子序列中排序为止。
*/
public static void hillSort(int[] arr) {
int temp;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
// 遍历各组中所有的元素(共gap组,每组有个元素), 步长gap
for (int j = i - gap; j >= 0; j -= gap) {
// 如果当前元素大于加上步长后的那个元素,说明交换
if (arr[j] > arr[j + gap]) {
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
}
}
/**
* 希尔排序(移位法),缩小增量的插入排序:设待排序元素序列有n个元素,首先取一个整数increment(小于n)作为间隔将全部元素分为increment个子序列,
* 所有距离为increment的元素放在同一个子序列中,在每一个子序列中分别实行直接插入排序。然后缩小间隔increment,
* 重复上述子序列划分和排序工作。直到最后取increment=1,将所有元素放在同一个子序列中排序为止。
*/
public static void hillSort2(int[] arr) {
int temp;
int j;
// 增量gap, 并逐步的缩小增量
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
// 从第gap个元素,逐个对其所在的组进行直接插入排序
for (int i = gap; i < arr.length; i++) {
temp = arr[i];
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
}
/**
* 快速排序:在序列中随便找一个数作为基准数,将这个序列中所有比基准数大的数放在右边,比基准数小的数放在左边
*/
public static void quickSort(int[] arr, int left, int right) {
if (left > right) {
return;
}
// 左下标
int l = left;
// 右下标
int r = right;
// pivot中轴值
int pivot = arr[(left + right) / 2];
int temp;
// while循环的目的是让比pivot 值小放到左边,比pivot值大放到右边
while (l < r) {
// 在pivot的左边一直找,找到大于等于pivot值,才退出
while (arr[l] < pivot) {
l++;
}
// 在pivot的右边一直找,找到小于等于pivot值,才退出
while (arr[r] > pivot) {
r--;
}
// 如果l >= r说明pivot 的左右两的值,已经按照左边全部是小于等于pivot值,右边全部是大于等于pivot值
if (l >= r) {
break;
}
// 交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
// 如果交换完后,发现这个arr[l] == pivot值 相等 r--, 前移
if (arr[l] == pivot) {
r--;
}
// 如果交换完后,发现这个arr[r] == pivot值 相等 l++, 后移
if (arr[r] == pivot) {
l++;
}
}
// 如果 l == r, 必须l++, r--, 否则为出现栈溢出
if (l == r) {
l++;
r--;
}
// 向左递归
quickSort(arr, left, r);
// 向右递归
quickSort(arr, l, right);
}
/**
* 归并排序:
* 第一, 分解: 把待排序的 n 个元素的序列分解成两个子序列, 每个子序列包括 n/2 个元素.
* 第二, 治理: 对每个子序列分别调用归并排序MergeSort, 进行递归操作
* 第三, 合并: 合并两个排好序的子序列,生成排序结果.
*/
public static void mergeSort(int[] arr, int left, int right, int[] temp) {
if (left < right) {
//中间索引
int mid = (left + right) / 2;
// 向左递归进行分解
mergeSort(arr, left, mid, temp);
// 向右递归进行分解
mergeSort(arr, mid + 1, right, temp);
// 合并
merge(arr, left, mid, right, temp);
}
}
/**
* @param arr 排序的原始数组
* @param left 左边有序序列的初始索引
* @param mid 中间索引
* @param right 右边索引
*/
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
// 初始化i, 左边有序序列的初始索引
int i = left;
// 初始化j, 右边有序序列的初始索引
int j = mid + 1;
// 指向temp数组的当前索引
int t = 0;
// 先把左右两边(有序)的数据按照规则填充到temp数组,直到左右两边的有序序列,有一边处理完毕为止
while (i <= mid && j <= right) {//继续
// 如果左边的有序序列的当前元素小于等于右边有序序列的当前元素,即将左边的当前元素填充到 temp数组,反之,将右边有序序列的当前元素填充到temp数组,然后 t++, i++
if (arr[i] <= arr[j]) {
temp[t++] = arr[i++];
} else {
temp[t++] = arr[j++];
}
}
// 把有剩余数据的一边的数据依次全部填充到temp
while (i <= mid) {
temp[t++] = arr[i++];
}
while (j <= right) {
temp[t++] = arr[j++];
}
// 将temp数组的元素拷贝到arr,注意,并不是每次都拷贝所有
for (int k = 0; k <= right - left; k++) {
arr[k + left] = temp[k];
}
}
/**
* 基数排序:将所有待比较数值统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
* 注意:这里只排序正数,且如果数据过大,则内存不足,1千万数据耗费内存:10000000 * 11 * 4 / 1024 /1024 /1024 = 0.4 G
*/
public static void radixSort(int[] arr) {
// 得到数组中最大的数的位数
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 得到最大数是几位数
int maxLength = (max + "").length();
// 定义一个二维数组,表示10个桶, 每个桶就是一个一维数组
int[][] bucket = new int[10][arr.length];
// 为了记录每个桶中,实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
int[] bucketEleCounts = new int[10];
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
// (针对每个元素的对应位进行排序处理), 第一次是个位,第二次是十位,第三次是百位..
for (int value : arr) {
int digitOfEle = value / n % 10;
bucket[digitOfEle][bucketEleCounts[digitOfEle]] = value;
bucketEleCounts[digitOfEle]++;
}
// 按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)
int index = 0;
// 遍历每一桶,并将桶中是数据,放入到原数组
for (int k = 0; k < bucketEleCounts.length; k++) {
// 如果桶中有数据,我们才放入到原数组
if (bucketEleCounts[k] != 0) {
for (int l = 0; l < bucketEleCounts[k]; l++) {
arr[index++] = bucket[k][l];
}
}
// 第i+1轮处理后,需要将每个 bucketEleCounts[k] = 0
bucketEleCounts[k] = 0;
}
}
}
/** 打印数组 */
public static String printArray(int[] arr) {
// System.out.println(Arrays.toString(arr));
return "如上";
}
public static void main(String[] args) {
int sum = 100000;
int[] arr = new int[sum];
for (int i = 0; i < sum; i++) {
arr[i] = new Random().nextInt(sum);
}
// int[] arr = {7, 4, 3, 3, 5, 8, 4, 5, 3, 8};
int[] arr2 = Arrays.copyOf(arr, sum);
int[] arr3 = Arrays.copyOf(arr, sum);
int[] arr4 = Arrays.copyOf(arr, sum);
int[] arr5 = Arrays.copyOf(arr, sum);
int[] arr6 = Arrays.copyOf(arr, sum);
int[] arr7 = Arrays.copyOf(arr, sum);
int[] arr8 = Arrays.copyOf(arr, sum);
int[] arr9 = Arrays.copyOf(arr, sum);
// System.out.println("排序前数组:" + Arrays.toString(arr));
Instant start = Instant.now();
radixSort(arr9);
System.out.println("基数排序(数据量不可过大)耗时(毫秒):" + Duration.between(start, Instant.now()).toMillis() + ", 排序后数组:" + printArray(arr9));
start = Instant.now();
mergeSort(arr8, 0, arr8.length - 1, new int[arr8.length]);
System.out.println("归并排序耗时(毫秒):" + Duration.between(start, Instant.now()).toMillis() + ", 排序后数组:" + printArray(arr8));
start = Instant.now();
quickSort(arr7, 0, arr7.length - 1);
System.out.println("快速排序耗时(毫秒):" + Duration.between(start, Instant.now()).toMillis() + ", 排序后数组:" + printArray(arr7));
start = Instant.now();
hillSort2(arr6);
System.out.println("希尔排序(移位法)耗时(毫秒):" + Duration.between(start, Instant.now()).toMillis() + ", 排序后数组:" + printArray(arr6));
start = Instant.now();
hillSort(arr5);
System.out.println("希尔排序(交换法)耗时(毫秒):" + Duration.between(start, Instant.now()).toMillis() + ", 排序后数组:" + printArray(arr5));
start = Instant.now();
insertSort(arr4);
System.out.println("插入排序耗时(毫秒):" + Duration.between(start, Instant.now()).toMillis() + ", 排序后数组:" + printArray(arr4));
start = Instant.now();
insertSort2(arr3);
System.out.println("插入2排序耗时(毫秒):" + Duration.between(start, Instant.now()).toMillis() + ", 排序后数组:" + printArray(arr3));
start = Instant.now();
selectSort(arr2);
System.out.println("选择排序耗时(毫秒):" + Duration.between(start, Instant.now()).toMillis() + ", 排序后数组:" + printArray(arr2));
start = Instant.now();
bubbleSort(arr);
System.out.println("冒泡排序耗时(毫秒):" + Duration.between(start, Instant.now()).toMillis() + ", 排序后数组:" + printArray(arr));
}
}
输出:
基数排序(数据量不可过大)耗时(毫秒):24
归并排序耗时(毫秒):16
快速排序耗时(毫秒):28
希尔排序(移位法)耗时(毫秒):19
希尔排序(交换法)耗时(毫秒):9092
插入排序耗时(毫秒):741
插入2排序耗时(毫秒):4861
选择排序耗时(毫秒):14161
冒泡排序耗时(毫秒):14625
测试效率:归并排序、快速排序、希尔排序(移位法) > 插入排序 > 选择排序、冒泡排序