Java排序算法
排序算法
一、概述
排序算法(Sort Algorithm)，排序是将一组数据依指定的顺序进行排列的过程
1. 分类
1.1 内部排序
将需要处理的所有数据都加载到**内部存储器(内存)**中进行排序
1.2 外部排序
数据量过大时，无法全部加载到内存中，需要借助外部存储器进行排序
2. 常见排序算法
二、算法的时间复杂度
1. 时间频度
一个算法花费的时间与算法中语句的执行次数成正比例，算法中语句的执行次数越多，则它花费的时间就越多。一个算法中的语句执行次数称为语句频度或时间频度，记为：T(n)
2. 举例说明
- 2*n+20和2n随着n的增大，两个表达式的结果会逐渐接近
- 2n2+3n+10和2n2随着n增大，两个表达式的值会逐渐接近
- 随着n的增大，5n2+7n和3n2+2n结果逐渐接近
结论：
- 常数项可以忽略
- 低次项可以忽略
- 高次项系数可以忽略
3. 时间复杂度
-
一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n)的极限值为不等于零的常数，则称f(n)为T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n))为算法的渐进时间复杂度，简称时间复杂度
-
T(n)不同，当时间复杂度可能相同。如：T(n)=n2+7n+6与T(n)=3n2+2n+2它们的T(n)不同但时间复杂度都为O(n^2)
-
计算方法：
- 用常数1代替运行时间中所有加法常数
- 修改后的运行次数中只保留最高阶项
- 去除最高阶项的系数
4. 常见的时间复杂度
- 常数阶O(1)
- 对数阶O(
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6QUEp7AU-1580721678273)(F:\Java笔记\图片\对数公式.png)]](http://img.e-com-net.com/image/info8/eeac21df8cc0430ab8012198bb8dc85b.png)
) - 线性阶O(n)
- 线性对数阶O(n
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NJp1bpyD-1580721678274)(F:\Java笔记\图片\对数公式.png)]](http://img.e-com-net.com/image/info8/59945bd3ab9f43f0ae9c53abe920d9cf.png)
) - 平方阶O(n^2)
- 立方阶O(n^3)
- k次方阶O(n^k)
- 指数阶O(2^n)
说明：
- 常见的算法复杂度由小到大依次为：O(1)
| 排序法 | 平均时间 | 最差时间 | 稳定度 | 额外空间 | 备注 |
|---|---|---|---|---|---|
| 冒泡 | O(n^2) | O(n^2) | 稳定 | O(1) | 当n小时较好 |
| 交换 | O(n^2) | O(n^2) | 不稳定 | O(1) | 当n小时较好 |
| 选择 | O(n^2) | O(n^2) | 不稳定 | O(1) | 当n小时较好 |
| 插入 | O(n^2) | O(n^2) | 稳定 | O(1) | 当大部分已经排序时较好 |
| 基数 |  |
 |
稳定 | O(n) | B是真数(0–9) R是基数(个十百) |
| Shell | O(n log n) | O(n^s) 1| 不稳定 |
O(1) |
s是所选分组 |
|
| 快速 | O(n log n) | O(n^2) | 不稳定 | O(n log n) | 当n大时较好 |
| 归并 | O(n log n) | O(n log n) | 稳定 | O(1) | 当n大时较好 |
| 堆 | O(n log n) | O(n log n) | 不稳定 | O(1) | 当n大时较好 |
三、算法的空间复杂度
- 一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它是问题规模n的函数
- 空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时将占用较多的存储单元，例如快速排序和归并排序
- 做算法分析时，主要讨论时间复杂度。从用户体验上看，更看重程序执行的速度。例如一些缓存产品和算法(基数排序)本质就是用空间换时间
四、冒泡排序
1. 概述
冒泡排序(Bubble Sorting)的基本思想是：通过对待排序序列从前向后(从下标较小的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部。
总结：
- 一共进行数组大小减一次大的循环
- 每一趟的排序次数在逐渐减少
- 如果发现在某趟排序中没有发生一次交换则可以结束排序
2. 代码演示
import java.util.Arrays;
/**
* @author DELL
* @Date 2020/2/1 12:19
**/
public class BubbleSort {
public static void main(String[] args) {
int [] arr={3,9,-1,10,-1};
boolean flag=true;
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length-i; j++) {
if(arr[j]>arr[j+1]){
flag=false;
int tmp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
}
}
if(flag){
break;
}else{
flag=true;
}
}
System.out.println(Arrays.toString(arr));
}
}
五、选择排序
1. 概述
选择排序(select sorting)也是一种简单的排序方法。它的基本思想是：第一次从arr[0]arr[n-1]中选择最小值，与arr[0]进行交换；第二次从arr[1]arr[n-1]中选取最小值，与arr[2]交换，……第i次从arr[i-1]arr[n-1]中选取最小值，与arr[i-1]交换，……第n-1次从arr[n-1]arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列
2. 代码演示
import java.util.Arrays;
/**
* @author DELL
* @Date 2020/2/1 14:02
**/
public class SelectSort {
public static void main(String[] args) {
int[] arr = {47, 24, 10, 9};
System.out.println("排序前：" + Arrays.toString(arr));
selectSort(arr);
System.out.println("排序后：" + Arrays.toString(arr));
}
/**
* 选择排序
*
* @param arr
*/
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = arr[i];
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < min) {
minIndex = j;
min = arr[j];
}
}
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
}
}
}
六、插入排序
1. 概述
插入排序(Insertion Sorting)的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只有一个元素，无序表中有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表的元素的排序码进行比较，将它插入到有序表的适当位置，使之成为新的有序表
2. 代码演示
import java.util.Arrays;
/**
* @author DELL
* @Date 2020/2/1 16:27
**/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {101, 34, 119, 1};
System.out.println("排序前：" + Arrays.toString(arr));
insertSort(arr);
System.out.println("排序后：" + Arrays.toString(arr));
}
/**
* 插入排序
* @param arr
*/
public static void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int insertVal = arr[i];
//要找的位置
int insertIndex = i - 1;
while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];
insertIndex--;
}
if(insertIndex+1!=i){
arr[insertIndex + 1] = insertVal;
}
}
}
}
七、希尔排序
1. 概述
希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序改进后的一种更高效的版本，也称为缩小增量排序
基本思想：
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分为一组，算法便终止
2. 代码演示
import java.util.Arrays;
/**
* @author DELL
* @Date 2020/2/2 19:30
**/
public class ShellSort {
public static void main(String[] args) {
int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
shellSort(arr);
}
public static void shellSort(int[] arr) {
int count = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
int j = i;
int temp = arr[j];
if (arr[j] < arr[j - gap]) {
while (j - gap >= 0 && temp < arr[j - gap]) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
}
System.out.println("希尔排序第" + (++count) + "轮=" + Arrays.toString(arr));
}
}
}
八、快速排序
1. 概述
快速排序(Quicksort)是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成两部分，其中一部分的所有数据都比另外一部分的所以数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此将整个数据变成有序的
2. 代码演示
import java.util.Arrays;
/**
* @author DELL
* @Date 2020/2/2 20:27
**/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {-9, 78, 0, 23, -567, 70};
quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
/**
* 快速排序
*
* @param arr
* @param left
* @param right
*/
public static void quickSort(int[] arr, int left, int right) {
int l = left;
int r = right;
int pivot = arr[(l + r) / 2];
int temp = 0;
while (l < r) {
while (arr[l] < pivot) {
l += 1;
}
while (arr[r] > pivot) {
r -= 1;
}
if (l >= r) {
break;
}
temp = arr[r];
arr[r] = arr[l];
arr[l] = temp;
if (arr[l] == pivot) {
r -= 1;
}
if (arr[r] == pivot) {
l += 1;
}
}
if (l == r) {
l += 1;
r -= 1;
}
//向左递归
if (left < r) {
quickSort(arr, left, r);
}//向右递归
if (right > l) {
quickSort(arr, l, right);
}
}
}
九、归并排序
1. 概述
归并排序(MERGE-SORT)是利用归并的思想实现的排序方法，该算法采用经典的分治(divide-and-conquer)策略，将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案修补在一起。
2，代码演示
import java.util.Arrays;
/**
* @author DELL
* @Date 2020/2/3 11:16
**/
public class MergeSort {
public static void main(String[] args) {
int[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
int[] temp = new int[arr.length];
mergeSort(arr, 0, arr.length - 1, temp);
System.out.println("排序后" + Arrays.toString(arr));
}
/**
* 归并排序
*
* @param arr
* @param left
* @param right
* @param temp
*/
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 右边索引
* @param temp 中转数组
*/
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
int i = left;
int j = mid + 1;
int t = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[t] = arr[i];
t += 1;
i += 1;
} else {
temp[t] = arr[j];
t += 1;
j += 1;
}
}
//将左边剩余的元素进行拷贝
while (i <= mid) {
temp[t] = arr[i];
t += 1;
i += 1;
}
//将右边剩余的元素进行拷贝
while (j <= right) {
temp[t] = arr[j];
t += 1;
j += 1;
}
//将temp数组的元素拷贝到arr
t = 0;
int tempLeft = left;
while (tempLeft <= right) {
arr[tempLeft] = temp[t];
t += 1;
tempLeft += 1;
}
}
}
十、基数排序
1. 概述
基数排序介绍(桶排序)：
- 基数排序(bucket sort)属于“分配式排序”(distribution sort)，又称为“桶子法”或bin sort，它是通过键值的各个位的值将要排序的元素分配至某些“桶”中，达到排序的作用
- 基数排序是属于稳定性的排序，基数排序法是效率高的稳定性排序法
- 基数排序是桶排序法的扩展
- 基数排序是1887年赫尔曼 何乐礼发明的。它将整数按照位数切割成不同的数字，然后按每个位数分别比较
基数排序基本思想：
- 将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后从低位开始，依次进行依次排序。这样从低位排序一直到最高位排序完成以后，数列就变成为一个有序数列
- 图文解释：
2. 代码演示
import java.util.Arrays;
/**
* @author DELL
* @Date 2020/2/3 16:24
**/
public class RadixSort {
public static void main(String[] args) {
int[] arr = {53, 3, 542, 748, 14, 214};
radixSort(arr);
System.out.println("排序后：" + Arrays.toString(arr));
}
/**
* 基数排序
*
* @param arr
*/
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();
for (int k = 0, n = 1; k < maxLength; k++, n *= 10) {
//定义二维数组，每个一维数组表示一个桶
int[][] bucket = new int[10][arr.length];
//记录每个桶中实际放入的元素个数
int[] bucketElementCounts = new int[10];
for (int i = 0; i < arr.length; i++) {
int digitOfElement = arr[i] / n % 10;
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[i];
bucketElementCounts[digitOfElement]++;
}
//遍历每一个桶，将数据放入原数组
int index = 0;
for (int i = 0; i < bucket.length; i++) {
//若桶中有数据我们才放入原数组
if (bucketElementCounts[i] != 0) {
for (int j = 0; j < bucketElementCounts[i]; j++) {
arr[index++] = bucket[i][j];
}
}
bucketElementCounts[i] = 0;
}
}
}
}
说明：
- 基数排序是通过空间换时间，当有海量数据时可能出现OutOfMemoryError
- 有负数的数组，不用基数排序进行排序
十一、堆排序
1. 概述
-
堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏、最好、平均时间复杂度均为O(logn)，它也是不稳定排序
-
堆是具有以下性质的完全二叉树：每个节点的值都大于或等于其左右节点的值，称为大顶堆，注意：没有要求左右孩子值的大小关系
-
每个节点的值都小于或等于其左右孩子的值，称为小顶堆
-
大顶堆举例：
-
一般升序采用大顶堆，降序采用小顶堆
2. 堆排序的基本思想
- 将待排序序列构造称为一个大顶堆
- 此时，整个序列的最大值就是堆顶的根节点
- 将其与末尾元素进行交换，此时末尾就是最大值
- 然后将剩余n-1个元素重新构造成为一个堆，这样会得到n个元素的次小值，如此反复则可得到一个有序序列
3. 代码演示
import java.util.Arrays;
/**
* @author DELL
* @Date 2020/2/8 11:50
**/
public class HeapSort {
public static void main(String[] args) {
int arr[] = {4, 6, 8, 5, 9};
heapSort(arr);
System.out.println("排序后：" + Arrays.toString(arr));
}
public static void heapSort(int[] arr) {
int temp = 0;
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
for (int i = arr.length - 1; i > 0; i--) {
temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
adjustHeap(arr, 0, i);
}
}
/**
* @param arr 要调整的数组
* @param i 表示非叶子节点在数组中的索引
* @param length 表示对多少个元素进行调整
*/
public static void adjustHeap(int[] arr, int i, int length) {
int temp = arr[i];
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
if (k + 1 < length && arr[k] < arr[k + 1]) {
k++;
}
if (arr[k] > temp) {
arr[i] = arr[k];
i = k;
} else {
break;
}
}
arr[i] = temp;
}
}