xplly'Blog

字数

4583 字

阅读时间

22 分钟

菜鸟排序算法

1. 二分查找

前提：有已排序数组 A（假设已经做好）
定义左边界 L、右边界 R，确定搜索范围，循环执行二分查找（3、4两步）
获取中间索引 M = Floor((L+R) /2)
中间索引的值 A[M] 与待搜索的值 T 进行比较
① A[M] == T 表示找到，返回中间索引
② A[M] > T，中间值右侧的其它元素都大于 T，无需比较，中间索引左边去找，M - 1 设置为右边界，重新查找
③ A[M] < T，中间值左侧的其它元素都小于 T，无需比较，中间索引右边去找， M + 1 设置为左边界，重新查找
当 L > R 时，表示没有找到，应结束循环

更形象的描述请参考：binary_search.html

算法实现

java

public static int binarySearch(int[] a, int t) {
    int l = 0, r = a.length - 1, m;
    while (l <= r) {
        m = (l + r) / 2;
        if (a[m] == t) {
            return m;
        } else if (a[m] > t) {
            r = m - 1;
        } else {
            l = m + 1;
        }
    }
    return -1;
}

测试代码

java

public static void main(String[] args) {
    int[] array = {1, 5, 8, 11, 19, 22, 31, 35, 40, 45, 48, 49, 50};
    int target = 47;
    int idx = binarySearch(array, target);
    System.out.println(idx);
}

解决整数溢出问题

当 l 和 r 都较大时，l + r 有可能超过整数范围，造成运算错误，解决方法有两种：

java

int m = l + (r - l) / 2;

还有一种是：

java

int m = (l + r) >>> 1;

其它考法

有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时，查找成功需要比较的次数
使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时，需要经过（）次比较
在拥有128个元素的数组中二分查找一个数，需要比较的次数最多不超过多少次

对于前两个题目，记得一个简要判断口诀：奇数二分取中间，偶数二分取中间靠左。对于后一道题目，需要知道公式：

n = l o g_{2} N = l o g_{10} N / l o g_{10} 2

其中 n 为查找次数，N 为元素个数

2. 冒泡排序

算法描述

依次比较数组中相邻两个元素大小，若 a[j] > a[j+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是让最大的元素排至最后
重复以上步骤，直到整个数组有序

更形象的描述请参考：bubble_sort.html

算法实现

java

public static void bubble(int[] a) {
    for (int j = 0; j < a.length - 1; j++) {
        // 一轮冒泡
        boolean swapped = false; // 是否发生了交换
        for (int i = 0; i < a.length - 1 - j; i++) {
            System.out.println("比较次数" + i);
            if (a[i] > a[i + 1]) {
                Utils.swap(a, i, i + 1);
                swapped = true;
            }
        }
        System.out.println("第" + j + "轮冒泡"
                           + Arrays.toString(a));
        if (!swapped) {
            break;
        }
    }
}

优化点1：每经过一轮冒泡，内层循环就可以减少一次
优化点2：如果某一轮冒泡没有发生交换，则表示所有数据有序，可以结束外层循环

进一步优化

java

public static void bubble_v2(int[] a) {
    int n = a.length - 1;
    while (true) {
        int last = 0; // 表示最后一次交换索引位置
        for (int i = 0; i < n; i++) {
            System.out.println("比较次数" + i);
            if (a[i] > a[i + 1]) {
                Utils.swap(a, i, i + 1);
                last = i;
            }
        }
        n = last;
        System.out.println("第轮冒泡"
                           + Arrays.toString(a));
        if (n == 0) {
            break;
        }
    }
}

每轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数，如果这个值为零，表示整个数组有序，直接退出外层循环即可

3. 选择排序

算法描述

将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集
重复以上步骤，直到整个数组有序

更形象的描述请参考：selection_sort.html

算法实现

java

public static void selection(int[] a) {
    for (int i = 0; i < a.length - 1; i++) {
        // i 代表每轮选择最小元素要交换到的目标索引
        int s = i; // 代表最小元素的索引
        for (int j = s + 1; j < a.length; j++) {
            if (a[s] > a[j]) { // j 元素比 s 元素还要小, 更新 s
                s = j;
            }
        }
        if (s != i) {
            swap(a, s, i);
        }
        System.out.println(Arrays.toString(a));
    }
}

优化点：为减少交换次数，每一轮可以先找最小的索引，在每轮最后再交换元素

与冒泡排序比较

二者平均时间复杂度都是 $O (n^{2})$
选择排序一般要快于冒泡，因为其交换次数少
但如果集合有序度高，冒泡优于选择
冒泡属于稳定排序算法，而选择属于不稳定排序
- 稳定排序指，按对象中不同字段进行多次排序，不会打乱同值元素的顺序
- 不稳定排序则反之

稳定排序与不稳定排序

java

System.out.println("=================不稳定================");
Card[] cards = getStaticCards();
System.out.println(Arrays.toString(cards));
selection(cards, Comparator.comparingInt((Card a) -> a.sharpOrder).reversed());
System.out.println(Arrays.toString(cards));
selection(cards, Comparator.comparingInt((Card a) -> a.numberOrder).reversed());
System.out.println(Arrays.toString(cards));

System.out.println("=================稳定=================");
cards = getStaticCards();
System.out.println(Arrays.toString(cards));
bubble(cards, Comparator.comparingInt((Card a) -> a.sharpOrder).reversed());
System.out.println(Arrays.toString(cards));
bubble(cards, Comparator.comparingInt((Card a) -> a.numberOrder).reversed());
System.out.println(Arrays.toString(cards));

都是先按照花色排序（♠♥♣♦），再按照数字排序（AKQJ...）

不稳定排序算法按数字排序时，会打乱原本同值的花色顺序
```
[[♠7], [♠2], [♠4], [♠5], [♥2], [♥5]]
[[♠7], [♠5], [♥5], [♠4], [♥2], [♠2]]
```
原来 ♠2 在前 ♥2 在后，按数字再排后，他俩的位置变了
稳定排序算法按数字排序时，会保留原本同值的花色顺序，如下所示 ♠2 与 ♥2 的相对位置不变
```
[[♠7], [♠2], [♠4], [♠5], [♥2], [♥5]]
[[♠7], [♠5], [♥5], [♠4], [♠2], [♥2]]
```

4. 插入排序

算法描述

将数组分为两个区域，排序区域和未排序区域，每一轮从未排序区域中取出第一个元素，插入到排序区域（需保证顺序）
重复以上步骤，直到整个数组有序

更形象的描述请参考：insertion_sort.html

算法实现

java

// 修改了代码与希尔排序一致
public static void insert(int[] a) {
    // i 代表待插入元素的索引
    for (int i = 1; i < a.length; i++) {
        int t = a[i]; // 代表待插入的元素值
        int j = i;
        System.out.println(j);
        while (j >= 1) {
            if (t < a[j - 1]) { // j-1 是上一个元素索引，如果 > t，后移
                a[j] = a[j - 1];
                j--;
            } else { // 如果 j-1 已经 <= t, 则 j 就是插入位置
                break;
            }
        }
        a[j] = t;
        System.out.println(Arrays.toString(a) + " " + j);
    }
}

与选择排序比较

二者平均时间复杂度都是 $O (n^{2})$
大部分情况下，插入都略优于选择
有序集合插入的时间复杂度为 $O (n)$
插入属于稳定排序算法，而选择属于不稳定排序

提示

插入排序通常被同学们所轻视，其实它的地位非常重要。小数据量排序，都会优先选择插入排序

5. 希尔排序

算法描述

首先选取一个间隙序列，如 (n/2，n/4 … 1)，n 为数组长度
每一轮将间隙相等的元素视为一组，对组内元素进行插入排序，目的有二
① 少量元素插入排序速度很快
② 让组内值较大的元素更快地移动到后方
当间隙逐渐减少，直至为 1 时，即可完成排序

更形象的描述请参考：shell_sort.html

算法实现

java

private static void shell(int[] a) {
    int n = a.length;
    for (int gap = n / 2; gap > 0; gap /= 2) {
        // i 代表待插入元素的索引
        for (int i = gap; i < n; i++) {
            int t = a[i]; // 代表待插入的元素值
            int j = i;
            while (j >= gap) {
                // 每次与上一个间隙为 gap 的元素进行插入排序
                if (t < a[j - gap]) { // j-gap 是上一个元素索引，如果 > t，后移
                    a[j] = a[j - gap];
                    j -= gap;
                } else { // 如果 j-1 已经 <= t, 则 j 就是插入位置
                    break;
                }
            }
            a[j] = t;
            System.out.println(Arrays.toString(a) + " gap:" + gap);
        }
    }
}

参考资料

https://en.wikipedia.org/wiki/Shellsort

6. 快速排序

算法描述

每一轮排序选择一个基准点（pivot）进行分区
1. 让小于基准点的元素的进入一个分区，大于基准点的元素的进入另一个分区
2. 当分区完成时，基准点元素的位置就是其最终位置
在子分区内重复以上过程，直至子分区元素个数少于等于 1，这体现的是分而治之的思想（divide-and-conquer）
从以上描述可以看出，一个关键在于分区算法，常见的有洛穆托分区方案、双边循环分区方案、霍尔分区方案

更形象的描述请参考：quick_sort.html

单边循环快排（lomuto 洛穆托分区方案）

选择最右元素作为基准点元素
j 指针负责找到比基准点小的元素，一旦找到则与 i 进行交换
i 指针维护小于基准点元素的边界，也是每次交换的目标索引
最后基准点与 i 交换，i 即为分区位置

java

public static void quick(int[] a, int l, int h) {
    if (l >= h) {
        return;
    }
    int p = partition(a, l, h); // p 索引值
    quick(a, l, p - 1); // 左边分区的范围确定
    quick(a, p + 1, h); // 左边分区的范围确定
}

private static int partition(int[] a, int l, int h) {
    int pv = a[h]; // 基准点元素
    int i = l;
    for (int j = l; j < h; j++) {
        if (a[j] < pv) {
            if (i != j) {
                swap(a, i, j);
            }
            i++;
        }
    }
    if (i != h) {
        swap(a, h, i);
    }
    System.out.println(Arrays.toString(a) + " i=" + i);
    // 返回值代表了基准点元素所在的正确索引，用它确定下一轮分区的边界
    return i;
}

双边循环快排（不完全等价于 hoare 霍尔分区方案）

选择最左元素作为基准点元素
j 指针负责从右向左找比基准点小的元素，i 指针负责从左向右找比基准点大的元素，一旦找到二者交换，直至 i，j 相交
最后基准点与 i（此时 i 与 j 相等）交换，i 即为分区位置

要点

基准点在左边，并且要先 j 后 i
while( i < j && a[j] > pv ) j--
while ( i < j && a[i] <= pv ) i++

java

private static void quick(int[] a, int l, int h) {
    if (l >= h) {
        return;
    }
    int p = partition(a, l, h);
    quick(a, l, p - 1);
    quick(a, p + 1, h);
}

private static int partition(int[] a, int l, int h) {
    int pv = a[l];
    int i = l;
    int j = h;
    while (i < j) {
        // j 从右找小的
        while (i < j && a[j] > pv) {
            j--;
        }
        // i 从左找大的
        while (i < j && a[i] <= pv) {
            i++;
        }
        swap(a, i, j);
    }
    swap(a, l, j);
    System.out.println(Arrays.toString(a) + " j=" + j);
    return j;
}

快排特点

平均时间复杂度是 $O (n l o g_{2} n)$ ，最坏时间复杂度 $O (n^{2})$
数据量较大时，优势非常明显
属于不稳定排序

洛穆托分区方案 vs 霍尔分区方案

霍尔的移动次数平均来讲比洛穆托少3倍
https://qastack.cn/cs/11458/quicksort-partitioning-hoare-vs-lomuto

空穴法改进的双边快排，比较次数更少

java


import java.util.Arrays;

import static day01.sort.Utils.swap;

// 空穴法(双边循环法改进)
@SuppressWarnings("all")
public class QuickSort3 {
    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};
        System.out.println(Arrays.toString(a));
        quick(a, 0, a.length - 1);
    }

    private static void quick(int[] a, int l, int h) {
        if (l >= h) {
            return;
        }
        int p = partition(a, l, h);
        quick(a, l, p - 1);
        quick(a, p + 1, h);
    }

    private static int partition(int[] a, int l, int h) {
        int pv = a[l];
        int i = l;
        int j = h;
        while (i < j) {
            // j 从右找小的
            while (i < j && a[j] > pv) {
                j--;
            }
            if (i < j) {
                a[i] = a[j];
                i++;
            }
            // i 从左找大的
            while (i < j && a[i] <= pv) {
                i++;
            }
            if (i < j) {
                a[j] = a[i];
                j--;
            }
        }
        a[j] = pv;
        System.out.println(Arrays.toString(a) + " j=" + j);
        return j;
    }
}

霍尔分区的实现

java


import java.util.Arrays;

import static day01.sort.Utils.swap;

public class QuickSortHoare {
    public static void main(String[] args) {
//        int[] a = {1,2,3};
//        int[] a = {9, 3, 2, 1};
//        int[] a = {9, 3, 7, 2, 5, 8, 1, 4};
        int[] a = {1, 2, 3, 4, 5, 7, 8, 9};
        System.out.println(Arrays.toString(a));
        quick0(a, 0, a.length - 1);
    }

    private static void quick0(int[] a, int l, int h) {
        if (l >= h) {
            return;
        }
        int p = partition(a, l, h);
        colorPrint(a, l, p, p + 1, h);
        // 注意如果左边界选择了 p-1, 则会因为返回的 p 可能不是基准点位置导致出错
        quick0(a, l, p);
        quick0(a, p + 1, h);
    }

    private static void colorPrint(int[] a, int r1l, int r1h, int r2l, int r2h) {
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            if (i >= r1l && i <= r1h) {
                System.out.print("\033[31m" + a[i] + "\033[0m");
            } else if (i >= r2l && i <= r2h) {
                System.out.print("\033[34m" + a[i] + "\033[0m");
            } else {
                System.out.print("_");
            }
            if (i < a.length - 1) {
                System.out.print(" ");
            }
        }
        System.out.println("]");

    }

    private static int partition(int[] a, int l, int h) {
//        int pv = a[l];
        int pv = a[(l + h) >>> 1];
        System.out.println("pv=" + pv);
        int i = l - 1;
        int j = h + 1;
        while (true) {
            while (a[++i] < pv) {
            }
            while (a[--j] > pv) {
            }
            if (i >= j) {
                return j;
            }
            swap(a, i, j);
        }
    }
}

对四种分区实现的移动次数比较

java


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

import static day01.sort.Utils.swap;

public class LomutoVsHoare {

    public static void main(String[] args) {
        List<int[]> all1 = new ArrayList<>();
        List<int[]> all2 = new ArrayList<>();
        List<int[]> all3 = new ArrayList<>();
        List<int[]> all4 = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            int[] array = Utils.randomArray(10000);
            all1.add(array);
            all2.add(Arrays.copyOf(array, array.length));
            all3.add(Arrays.copyOf(array, array.length));
            all4.add(Arrays.copyOf(array, array.length));
        }
        System.out.println("hoarePartition");
        testPartition(all1, LomutoVsHoare::hoarePartition);
        System.out.println("LomutoPartition");
        testPartition(all2, LomutoVsHoare::LomutoPartition);
        System.out.println("otherPartition");
        testPartition(all3, LomutoVsHoare::otherPartition);
        System.out.println("moveInsteadSwapPartition");
        testPartition(all3, LomutoVsHoare::moveInsteadSwapPartition);
    }

    private static void testPartition(List<int[]> all, FourConsumer consumer) {
        List<AtomicInteger> cs = new ArrayList<>();
        for (int[] array : all) {
            AtomicInteger c = new AtomicInteger();
            consumer.apply(array, 0, array.length - 1, c);
            cs.add(c);
        }
        // 打印的是平均移动次数，而非交换次数，一次交换有3次移动
        System.out.println(cs + " avg:" + cs.stream().mapToLong(AtomicInteger::get).average().orElse(0));
    }

    interface FourConsumer {
        void apply(int[] a, int b, int c, AtomicInteger d);
    }

    private static int hoarePartition(int[] a, int l, int h, AtomicInteger c) {
//        int pv = a[l];
        int pv = a[(l + h) >>> 1];
        int i = l - 1;
        int j = h + 1;
        while (true) {
            while (a[++i] < pv) {
            }
            while (a[--j] > pv) {
            }
            if (i >= j) {
                return j;
            }
            c.accumulateAndGet(3, Integer::sum);
            swap(a, i, j);
        }
    }

    private static int LomutoPartition(int[] a, int l, int h, AtomicInteger c) {
        int pv = a[h];
        int i = l;
        for (int j = l; j < h; j++) {
            if (a[j] < pv) {
                if (i != j) {
                    c.accumulateAndGet(3, Integer::sum);
                    swap(a, i, j);
                }
                i++;
            }
        }
        if (i != h) {
            c.accumulateAndGet(3, Integer::sum);
            swap(a, h, i);
        }
        return i;
    }

    private static int otherPartition(int[] a, int l, int h, AtomicInteger c) {
        int pv = a[l];
        int i = l;
        int j = h;
        while (i < j) {
            while (i < j && a[j] > pv) {
                j--;
            }
            while (i < j && a[i] <= pv) {
                i++;
            }
            c.accumulateAndGet(3, Integer::sum);
            swap(a, i, j);
        }
        c.accumulateAndGet(3, Integer::sum);
        swap(a, l, i);
        return i;
    }

    private static int moveInsteadSwapPartition(int[] a, int l, int h, AtomicInteger c) {
        int pv = a[l];
        int i = l;
        int j = h;
        while (i < j) {
            // j 从右找小的
            while (i < j && a[j] > pv) {
                j--;
            }
            if (i < j) {
                c.incrementAndGet();
                a[i] = a[j];
                i++;
            }
            // i 从左找大的
            while (i < j && a[i] <= pv) {
                i++;
            }
            if (i < j) {
                c.incrementAndGet();
                a[j] = a[i];
                j--;
            }
        }
        c.incrementAndGet();
        a[j] = pv;
        return j;
    }


}

7. 归并排序

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

终归并排序的时间复杂度为O(nlogn);

缺点：需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的操作。

原理：

1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。

2.将相邻的两个子组进行合并成一个有序的大组；

3.不断的重复步骤2，直到最终只有一个组为止。

java


public class Merge {
    //归并所需要的辅助数组
    private static Comparable[] assist;

    /*
       比较v元素是否小于w元素
    */
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w)<0;
    }

    /*
    数组元素i和j交换位置
     */
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }


    /*
           对数组a中的元素进行排序
        */
    public static void sort(Comparable[] a) {
        //1.初始化辅助数组assist；
        assist = new Comparable[a.length];
        //2.定义一个lo变量，和hi变量，分别记录数组中最小的索引和最大的索引；
        int lo=0;
        int hi=a.length-1;
        //3.调用sort重载方法完成数组a中，从索引lo到索引hi的元素的排序
        sort(a,lo,hi);
    }

    /*
    对数组a中从lo到hi的元素进行排序
     */
    private static void sort(Comparable[] a, int lo, int hi) {
        //做安全性校验；
        if (hi<=lo){
            return;
        }

        //对lo到hi之间的数据进行分为两个组
        int mid = lo+(hi-lo)/2;//   5,9  mid=7

        //分别对每一组数据进行排序
        sort(a,lo,mid);
        sort(a,mid+1,hi);

        //再把两个组中的数据进行归并
        merge(a,lo,mid,hi);
    }

    /*
    对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
     */
    private static void merge(Comparable[] a, int lo, int mid, int hi) {
        //定义三个指针
        int i=lo;
        int p1=lo;
        int p2=mid+1;

        //遍历，移动p1指针和p2指针，比较对应索引处的值，找出小的那个，放到辅助数组的对应索引处
        while(p1<=mid && p2<=hi){
            //比较对应索引处的值
            if (less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else{
                assist[i++]=a[p2++];
            }
        }

        //遍历，如果p1的指针没有走完，那么顺序移动p1指针，把对应的元素放到辅助数组的对应索引处
        while(p1<=mid){
            assist[i++]=a[p1++];
        }
        //遍历，如果p2的指针没有走完，那么顺序移动p2指针，把对应的元素放到辅助数组的对应索引处
        while(p2<=hi){
            assist[i++]=a[p2++];
        }
        //把辅助数组中的元素拷贝到原数组中
        for(int index=lo;index<=hi;index++){
            a[index]=assist[index];
        }

    }

}

1. 二分查找 ​

2. 冒泡排序 ​

3. 选择排序 ​

4. 插入排序 ​

5. 希尔排序 ​

6. 快速排序 ​

7. 归并排序 ​

1. 二分查找

2. 冒泡排序

3. 选择排序

4. 插入排序

5. 希尔排序

6. 快速排序

7. 归并排序