算法系列 : 十大经典排序

冒泡排序

冒泡排序比较简单 , 没啥好说的 , 上代码

for (int i = 0; i < arr.length; i++) {
    int j = i;
    while (j >= 1 && arr[j] < arr[j - 1]) {
        int tmp = arr[j];
        arr[j] = arr[j - 1];
        arr[j - 1] = tmp;
        j--;
    }
}

选择排序

很无脑

for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr.length; j++) {
        if (arr[j] > arr[i]) {
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }
}

插入排序

插入排序基本思路 , 拖着当前数逐个往前找 , 直到上一个数比当前数小

Java实现

for (int i = 1; i < arr.length; i++) {
    int key = arr[i];
    int j = i - 1;
    while (j >= 0 && arr[j] > key) {
        arr[j + 1] = arr[j];
        j--;
    }
    arr[j + 1] = key;
}

三个基础排序写完了 , 先检测一下效率

冒泡的效率居然比插入高 , 估计是个伪冒泡 , 上维基查查 ...

int i, temp, len = arr.length;
boolean changed;
do {
    changed = false;
    len-=1;
    for (i = 0; i < len; i++) {
        if (arr[i] > arr[i + 1]) {
            temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
            changed = true;
        }
    }
} while (changed);

看结果 , 维基的冒泡经典真冒泡 , 思路也很简单

1.定义一个flag , changed

2.开始循环 , 如果有前一个数比后一个数大的情况 , 则替换这两个数

3.直到所有前面的数比后一个数大为止

总结下 , 如果把经典冒泡看作是一群泡往上冒 , 笔者的冒泡则更像一个一个泡往上冒 。

预热完了 , 下面进入正题

 

希尔排序

希尔排序是插入排序的优化版本 , 区别在于插入排序拽着当前数 , 每次只能往前爬一步 , 希尔则可自定义步进 , 希尔的步进最后必然为1 , 也就是说最后一轮循环 , 就是插入排序 , 祥见代码

for (int step = arr.length / 3; step >= 1; step /= 2)
    for (int i = step; i < arr.length; i++) {
        int key = arr[i];
        int j = i - step;
        while (j >= 0 && arr[j] > key) {
            arr[j + step] = arr[j];
            j -= step;
        }
        arr[j + step] = key;
    }

可以看到 , 20万长度的数组 , 排序耗时 , 希尔要比经典基础排序快两个量级

快速排序