排序算法:
排序是计算机内经常进行的一种操作,其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序,若整个排序过程不需要访问外存便能完成,则称此类排序问题为内部排序。反之,若参加排序的记录数量很大,整个序列的排序过程不可能在内存中完成,则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。博主主要介绍内部排序算法。
排序算法 | 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 | 稳定性 |
冒泡排序 | O(n2) | O(n) | O(n2) | O(1) | 稳定 |
选择排序 | O(n2) | O(n) | O(n2) | O(1) | 不 稳定 |
插入排序 | O(n2) | O(n) | O(n2) | O(1) | 稳定 |
希尔排序 | O(n2) | O(n) | O(n2) | O(1) | 不稳定 |
归并排序 | O(n2) | O(n) | O(n2) | O(n) | 稳定 |
快速排序 | O(n2) | O(n) | O(n2) | O(log n) | 不 稳定 |
堆排序 | O(n2) | O(n) | O(n2) | O(1) | 不稳定 |
计数排序 | O(n2) | O(n) | O(n2) | O(k) | 稳定 |
桶排序 | O(n + k) | O(n + k | O(n2) | O(n+k) | 稳定 |
基数排序 | O(n * k) | O(n * k) | O(n * k) | O(n+k) | 稳定 |
一、交换排序
1.1冒泡排序:
基本思想:通过对待排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒。
public static void bubbleSort(int a[]) {
//外循环控制躺数
for (int i = 0; i < a.length - 1; i++) {
//内循环控制比较得次数
for (int j = 1; j <= a.length - i - 1; j++) {
if (a[j] < a[j - 1]) {
int temp = a[j - 1];
a[j - 1] = a[j];
a[j] = temp;
}
}
}
}
1.2快速排序
基本思想:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列
public static void quickSort(int a[], int l, int r) {
if(l >= r)
return ;
int x =a[l];
int i = l - 1;
int j = r + 1;
while(i<j){
do i++;
while(a[i]<x);
do j--;
while(a[j]>x);
if(i < j){
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
quickSort(a,l,j);
quickSort(a,j+1,r);
}
二、插入排序
2.1插入排序
基本思想:把 n 个待排序的元素看成为一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含有 n-1 个元素,排序过程中每次从无序表中取出第一个元素,把它的排
序码依次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表。
public static void insertSort(int a[]) {
for (int i = 1; i < a.length; i++) {
int insertVal = a[i]; //待插入的数
int insertIndex = i - 1; //待插入数前面的数的下标
//insertIndex >= 0 保证插入位置没有越界
// insertVal < a[insertIndex] 未找到合适的位置
while (insertIndex >= 0 && insertVal < a[insertIndex]) {
a[insertIndex + 1] = a[insertIndex];
insertIndex--;
}
//判断是否需要赋值,若不赋值则说明待插入前的数有序,反之,将待插入的数插入适当的位置.
if (i != insertIndex) {
a[insertIndex + 1] = insertVal;
}
}
}
2.2希尔排序
基本思想:把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至 1 时,整个文件恰被分成一组,算法便终止
static void shellSort(int a[]) {
for (int gap = a.length / 2; gap > 0; gap /= 2) {
//分成gap个组,分别对组中元素进行插入排序
for (int i = gap; i < a.length; i++) {
int j = i;
int temp = a[j];
if (a[j] < a[j - gap]) {
while (j - gap >= 0 && temp < a[j - gap]) {
//移动
a[j] = a[j - gap];
j -= gap;
}
//退出循环,找到插入位置
a[j] = temp;
}
}
}
}
三、选择排序
3.1简单选择排序
基本思想是:第一次从 arr[0]~arr[n-1]中选取最小值,与 arr[0]交换,第二次从 arr[1]~arr[n-1]中选取最小值,与 arr[1]交换,第三次从 arr[2]~arr[n-1]中选取最小值,与 arr[2]交换,…,第 i 次从 arr[i-1]~arr[n-1]中选取最小值,与 arr[i-1]交换,…, 第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值,与 arr[n-2]交换,总共通过 n-1 次,得到一个按排序码从小到大排列的有序序列。
static void selectSort(int a[]) {
for (int i = 0; i < a.length; i++) {
int min = a[i];
int midIndex = i;
for (int j = i + 1; j < a.length; j++) {
if (min > a[j]) {
min = a[j];
midIndex = j;
}
}
if (midIndex != i) {
a[midIndex] = a[i];
a[i] = min;
}
}
}
四、归并排序
public static void merge(int a[],int l,int r){
if(l>=r) //结果只有一个退出
return;
int mid = l+r >>1;
merge(a,l,mid);
merge(a,mid+1,r);
int k = 0,i=l,j=mid+1;
while(i<=mid&&j<=r){ //合并
if(a[i]<=a[j]) res[k++] = a[i++];
else res[k++] = a[j++];
}
while(i <= mid) res[k++] = a[i++];
while(j<=r) res[k++] = a[j++];
for(i=l,j=0;i<=r;i++,j++){
a[i] = res[j];
}
}
五、基数排序
基本思想:将所有待比较数值统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
public static void radixSort(int[] a) {
int[][] res = new int[10][a.length];//二维数组作为桶
int[] k = new int[10];//记录每个桶中的数的个数
int max = Integer.MIN_VALUE;
for (int temp : a) {
if (temp > max) {
max = temp;
}
}
int times = (max + "").length();
//排序的次数根据数组中最大值的位数决定
for (int m = 0, n = 1; m < times; m++, n *= 10){
//分别根据个位、十位、百位、、进行排序
for (int i = 0; i < a.length; i++) {
int temp = a[i] / n % 10;
res[temp][k[temp]] = a[i];//将当前数据加入对应的桶中
k[temp]++;//对应桶中的数据+1
}
int index = 0;
//将桶中的数据重新加入到a数组中
for (int l = 0; l < 10; l++) {
if (k[l] != 0) {//判断桶中数据是否为空
for (int j = 0; j < k[l]; j++) {
a[index] = res[l][j];
index++;
}
}
k[l] = 0;//将当前桶中的数的个数清0
}
}
}