几个初级排序算法总结

几个初级排序算法总结（升序）

1.选择排序

a.首先找到数组中最小的元素，将它和数组第一个元素交换位置；
b.然后在剩下的元素中找到最小元素，将它与第二个元素交换位置；
c.如此反复，直到将数组排好序；

public static void selectionSort(int[] array) {
    int n = array.length;//先存下来，不用每次都计算
    for(int i = 0; i < n; i++) {
        int min = i;
        for(int j = i + 1; j < n; j++) {
            if(array[j] < array[min]) min = j;
        }//找到最小元素
        swap(array, i, min);//交换
    }
}

特点：

• 需要n次交换：每次交换能排定一个元素
• 选择排序时间效率O（$n^2$）取决于比较次数： $$（n-1)+（n-2)+…+2+1 =n^2/2$$
• 运行时间与输入无关：已经有序的数组和一个元素随机排列的数组耗费的时间一样长
• 数据移动是最少的：N次交换

---

2.插入排序

（就像整理扑克牌一样，将小的牌插到前面）

a.取索引i = 1；
b.将索引i处的元素比前一个元素小，就将前一个位置后移，再将它插到前面(即与前一个元素交换位置）；
c.如此反复，直到索引i前面的数都是排好序的；
d. i++，开始下一趟

public static void insertionSort(int[] array) {
    int n = array.length;
    for(int i = 0; i < n; i++) {
        for(int j = i; j > 0 && array[j] < array[j-1]; j--) {
            swap(array, j, j - 1);
        }
    }
}

特点：（对于长度为$n$且主键不重复的数组）复杂度为O（$n^2$）

• 稳定的排序
• 平均情况需要 $n^2/4$ 比较和 $n^2/4$ 次交换
• 最好情况 $n-1$ 次比较，0次交换；（有序数组）
• 最坏情况 $n^2/2$ 比较和 $n^2/2$ 次交换
• 需要交换的次数等于数组中倒置的数量 $k$
• 需要比较的次数 $k \leq m \leq n+k-1$

---

3. 希尔排序

思想：使数组中任意间隔为h的元素都是有序的（称h有序），并用插入排序将h个子数组独立地排序。

public static void shellSort(int[] array, int k) {
    //数组划分为k部分
    int n = array.length;
    int h = 1;
    while (h < (n / k))
        //初识化间隔
        h = k * h + 1;
    while(h >= 1) {
        //用插入排序将数组变为h有序
        for(int i = h; i < n; i++) {
            for(int j = i; j >= h && a[j] < a[j-h]; j -= h) {
                swap(array, j, j - h);
            }
        }
        h = h / k;
    }
}

特点：

• 比插入排序和选择排序快，数组越大优势越大
• 复杂度不超过O（$n^2$）,可以改变递增序列优化复杂度
• 最坏情况下比较次数和 $n^{k/k-1}$ 成正比
• 通常应用环境综合效率最佳的递增序列：{1，5，19，41，109，209，505，…}其中各项，均为$9*4^k-9*2^k+1$或$4^k-3*2^k+1$的形式。如此改进后，最坏情况复杂度为O（$n^{3/4}$）,平均复杂度为O（$n^{7/6}$）。

---

注：这三种排序都能用于数组和链表

参考:算法（第四版），数据结构（C++版)