排序算法概述
引用微信文章的图:
下面依次介绍直接插入、shell排序、直接选择、堆排序、冒泡排序、快速排序、归并排序。
1.直接插入
思想:从数组的左边依次判断,每次判断当前索引与左边的数是否是有序的,其最终位置不确定。
分析:插入排序所需的时间取决于元素的初始顺序,最好的情况是有序,则需要N-1次比较和0次交换,最坏的情况是倒序,需N(N-1)/2次比较和N(N-1)/2次交换。
适合条件:部分有序的数组。
java实现代码:
public void insertSort(int[] a) {
// 将a[]按升序排列
for (int i = 1; i < a.length; i++) {
// 将a[i]插入到a[i-1],a[i-2],...之中
for (int j = i; j >= 1 && a[j] < a[j - 1]; j--)
exch(a, j, j - 1);
}
}
2.shell排序
思想:使数组中任意间隔为h的元素都是有序的。当h很大时,能将元素移动到很远的地方,为实现更小的h有序创造方便。
分析:所需的平均比较次数无法确定,但突破了平方级的运算时间。
java实现代码:public void shellSort(int[] a) {
// 将a[]按升序排列
int n = a.length;
int h = 1;
while (h < n / 3)
h = 3 * h + 1;
while (h >= 1) {
for (int i = h; i < n; i++) {
for (int j = i; j >= h && a[j] < a[j - h]; j--)
exch(a, j, j - h);
}
h = h / 3;
}
}
3.选择排序
思想:首先,找到数组中最小的那个元素,然后将它和数组的第一个元素交换位置。再次,在剩下的元素中找到最小的元素,将它与数组的第二个元素交换位置。如此往复,直到将整个数组排序。
分析:时间复杂度:O(n^2) 需做n^2/2次比较和n次交换
java实现代码:
public void selectSort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
int min = i;
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[min])
min = j;
}
exch(a, i, min);
}
}
4.堆排序
步骤:首先将待排序数组变成最大堆,满足父节点的值都比其子节点大:只需对1~n/2做下沉操作(该节点和其子节点比较,选取最大的值放在该节点的位置,若最大的值是子节点,则继续对子节点做下沉操作),因为n/2+1~n是叶子节点,无子节点;然后将最大的根节点和最末尾的值交换,此时最大的值在正确的位置,此后的操作不考虑该位置了:把最大堆的数量减1,而根节点的位置不符最大堆,需重新最大堆化:对根节点进行相同的下沉操作:把根节点往下和子节点比较,该节点往下移,最大值上移,将最大值重新放到根节点位置且保证是最大堆,再重复以上操作。
分析:
时间复杂度:O(nlogn)
空间复杂度:O(1)
稳定性:不稳定
java实现代码:public void maxHeapSort(int[] a) {
// 先对数组的n/2-1~1-1做下沉操作,以保证数组最大堆化
int n = a.length;
for (int i = n / 2; i >= 1; i--)
sink(a, i, n);
// 将第一个最大值和最末尾的值交换,并重新对第一个根节点位置的数做下沉操作,重新做最大堆化,依次循环n-1次
while (n > 1) {
exch(a, 0, --n);
sink(a, 1, n);
}
}
public void sink(int[] a, int i, int n) {
while (2 * i <= n) {
int j = 2 * i;
if (j < n && a[j - 1] < a[j + 1 - 1])
j++;
if (a[i - 1] > a[j - 1])
break;
exch(a, i - 1, j - 1);
i = j;
}
}
5.冒泡排序
步骤:将临近的两个数进行两两比较,按照从小到大的顺序进行交换,一趟冒泡后,最大的数被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束。
public void bubbleSort(int[] a){
int n=a.length;
for(int i=0;i<n-1;i++)
//每经过一次冒泡,会将最大值冒泡到当前最末尾位置,因此下次冒泡时可以忽略有序的末尾位置
for(int j=0;j<n-1-i;j++){
if(a[j]>a[j+1])
exch(a, j, j+1);
}
}
6.快速排序
步骤:用数组的第一个数把整个数组分为两部分,一部分的数比这个数小,另一部分的数比这个数大,之后只需对两个部分数组进行排序即可,采用了分治的思想(这个过程中也会对数组的数进行部分交换)
分析:
时间复杂度:
最快O(nlogn),最慢O(n^2)-退化为选择排序,每次分成两部分时,其中一部分的数只有1个
空间复杂度:O(nlogn)
稳定性:
不稳定
java实现代码:public void quickSort(int[] a) {
quickSort(a, 0, a.length - 1);
}
public void quickSort(int[] a, int start, int end) {
if (end <= start)
return;
int j = partion(a, start, end);
quickSort(a, start, j - 1);
quickSort(a, j + 1, end);
}
public int partion(int[] a, int start, int end) {
int v = a[start];
int i = start, j = end + 1;
while (true) {
while (a[++i] <= v) {
if (i == end)
break;
}
while (a[--j] >= v) {
if (j == start)
break;
}
if (j <= i)
break;
exch(a, i, j);
}
exch(a, start, j);
return j;
}
7.归并排序
步骤:将两个有序的数组归并成一个更大的有序数组,采用分治思想
分析:
时间复杂度:O(nlogn)
空间复杂度:O(n)
java实现代码:
public void mergeSort(int[] a) {
mergeSort(a, 0, a.length - 1);
}
public void mergeSort(int[] a, int lo, int hi) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
mergeSort(a, lo, mid);
mergeSort(a, mid + 1, hi);
merge(a, lo, mid, hi);
}
public void merge(int[] a, int lo, int mid, int hi) {
int[] aux = new int[a.length];
int i = lo, j = mid + 1;
for (int k = lo; k <= hi; k++)
aux[k] = a[k];
for (int k = lo; k <= hi; k++) {
if (i > mid)
a[k] = aux[j++];
else if (j > hi)
a[k] = aux[i++];
else if (a[i] < a[j])
a[k] = aux[i++];
else
a[k] = aux[j++];
}
}