排序算法 - MikeYan01

常用的排序算法

算法一览#

冒泡排序#

比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

优化思路：立一个flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。

1
public int[] bubbleSort(int[] arr) {
2
    for (int i = 1; i < arr.length; i++) {
3
        // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
4
        boolean flag = true;
5

6
        for (int j = 0; j < arr.length - i; j++) {
7
            if (arr[j] > arr[j + 1]) {
8
                int tmp = arr[j];
9
                arr[j] = arr[j + 1];
10
                arr[j + 1] = tmp;
11

12
                flag = false;
13
            }
14
        }
15

16
        if (flag) {
17
            break;
18
        }
19
    }
20
    return arr;
21
}

选择排序#

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。重复第二步，直到所有元素均排序完毕。

1
public int[] selectionSort(int[] arr) {
2
    // 总共要经过 N-1 轮比较
3
    for (int i = 0; i < arr.length - 1; i++) {
4
        int minIndex = i;
5

6
        // 每轮需要比较的次数 N-i
7
        for (int j = i + 1; j < arr.length; j++)
8
            if (arr[j] < arr[minIndex]) {
9
                minIndex = j; // 记录目前能找到的最小值元素的下标
10
            }
11

12
        // 将找到的最小下标和i进行交换
13
        if (i != minIndex) {
14
            int tmp = arr[i];
15
            arr[i] = arr[minIndex];
16
            arr[minIndex] = tmp;
17
        }
18
    }
19
    return arr;
20
}

插入排序#

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）（联想打扑克时整理手牌）

优化思路：希尔排序

1
public int[] insertionSort(int[] arr) {
2
    // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
3
    for (int i = 1; i < arr.length; i++) {
4

5
        // 当前要插入的数据
6
        int tmp = arr[i];
7

8
        // 从已经排序的序列最右边的开始比较，如果找到比其小的数，把这个数右移一位，腾位置给要插入的数
9
        int j = i;
10
        while (j > 0 && tmp < arr[j - 1]) {
11
            arr[j] = arr[j - 1];
12
            j--;
13
        }
14

15
        // 存在比其小的数，插入
16
        if (j != i) {
17
            arr[j] = tmp;
18
        }
19
    }
20
    return arr;
21
}

希尔排序#

把记录按下标的一定增量（gap）分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

希尔排序的gap选择与证明是个数学难题，希尔建议的gap是数组长度的一半。

1
public int[] shellSort(int[] arr) {
2
    // 初始gap的选择
3
    int gap = arr.length / 2;
4

5
    while (gap > 0) {
6
        // 从下标为gap的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
7
        for (int i = gap; i < arr.length; i++) {
8
            // 当前要插入的数据
9
            int tmp = arr[i];
10

11
            // 从已经排序的序列最右边的开始比较，如果找到比其小的数，把这个数右移gap位，腾位置给要插入的数
12
            int j = i - gap;
13
            while (j >= 0 && tmp < arr[j]) {
14
                arr[j + gap] = arr[j];
15
                j -= gap;
16
            }
17
            arr[j + gap] = tmp;
18
        }
19
        gap = gap / 2; // gap缩小
20
    }
21
    return arr;
22
}

归并排序#

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。设定两个指针分别指向两个已经排序序列的起始位置，不断比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置。如果一个序列到达末尾，再把另一个序列的剩余元素添加到合并序列的末尾。

1
public void mergeSort(int[] result, int[] data, int left, int right) {
2
    if (left >= right) {
3
        return;
4
    }
5

6
    int mid = left + (right - left) / 2;
7

8
    // 双指针，确定两个子数组的起始下标
9
    int ptr1 = left;
10
    int ptr2 = mid + 1;
11

12
    // 分治
13
    mergeSort(result, data, left, mid);
14
    mergeSort(result, data, mid+1, right);
15

16
    // 按照双指针进行排序
17
    int index = left;
18
    while (ptr1 <= mid && ptr2 <= right) {
19
        result[index++] = data[ptr1] < data[ptr2] ? data[ptr1++] : data[ptr2++];
20
    }
21

22

23
    // 两个循环只会执行一个，即：拷贝那个有剩余的数组
24
    while (ptr1 <= mid) {
25
        result[index++] = data[ptr1++];
26
    }
27
    while (ptr2 <= right) {
28
        result[index++] = data[ptr2++];
29
    }
30

31
    // 把排好序的结果覆盖掉原始的数组
32
    for (index = left; index <= right; index++) {
33
        data[index] = result[index];
34
    }
35
}

快速排序#

从数列中挑出一个元素，称为 “基准”（pivot）。重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数放到任意一边），这个步骤称为称为分区（partition）操作。递归地把小于基准值元素的子数列和大于基准值元素的子数列都进行排序。

1
public int partition(int[] data, int left, int right) {
2
    int pivot = data[left]; // 初始pivot
3

4
    // 范围内搜寻比pivot小或大的元素，然后将左侧元素与右侧元素交换
5
    while (left < right) {
6
        while (data[right] >= pivot && left < right) {
7
            right--;
8
        }
9
        data[left] = data[right];
10

11
        while (data[left] <= pivot && left < right) {
12
            left++;
13
        }
14
        data[right] = data[left];
15
    }
16

17
    data[left] = pivot;
18
    return left;
19
}
20

21
public void quickSort(int[] data, int begin, int end) {
22
    if (begin >= end) {
23
        return;
24
    }
25

26
    int pivot = partition(data, begin, end);
27

28
    // 两个子数组分治排序
29
    quickSort(data, begin, pivot - 1);
30
    quickSort(data, pivot + 1, end);
31
}

堆排序#

创建一个堆 H[0……n-1]，把堆首（最大值）和堆尾互换；把堆的尺寸缩小1，把新的数组顶端数据调整到相应位置；重复步骤2，直到堆的尺寸为1。

1
public int[] heapSort(int[] arr) {
2
    int len = arr.length;
3

4
    // 构造堆
5
    for (int i = len / 2; i >= 0; i--) {
6
        heapify(arr, i, len);
7
    }
8

9
    for (int i = len - 1; i > 0; i--) {
10
        swap(arr, 0, i); // 把堆顶最大值和堆尾互换
11
        len--; // 堆的尺寸减少1
12
        heapify(arr, 0, len); // 新的堆顶调整到相应位置
13
    }
14

15
    return arr;
16
}
17

18
private void heapify(int[] arr, int i, int len) {
19
    int left = 2*i + 1, right = 2*i + 2;
20

21
    // 判断两个儿子是否比当前节点大，如果有，返回最大的那个
22
    int max = i;
23
    if (left < len && arr[left] > arr[max]) {
24
        max = left;
25
    }
26
    if (right < len && arr[right] > arr[max]) {
27
        max = right;
28
    }
29

30
    if (max != i) {
31
        swap(arr, i, max); // 交换父子
32
        heapify(arr, max, len); // 调整当前最大节点到堆尾
33
    }
34
}
35

36
private void swap(int[] arr, int i, int j) {
37
    int temp = arr[i];
38
    arr[i] = arr[j];
39
    arr[j] = temp;
40
}

计数排序#

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组C中。找出待排序的数组中最大和最小的元素，统计数组中每个值为i的元素出现的次数，存入数组C的第i项。对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加），将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

1
private int getMinValue(int[] arr) {
2
    int minValue = arr[0];
3
    for (int value : arr) {
4
        if (minValue > value) {
5
            minValue = value;
6
        }
7
    }
8

9
    return minValue;
10
}
11

12
private int getMaxValue(int[] arr) {
13
    int maxValue = arr[0];
14
    for (int value : arr) {
15
        if (maxValue < value) {
16
            maxValue = value;
17
        }
18
    }
19

20
    return maxValue;
21
}
22

23
private int[] countingSort(int[] arr, int minValue, int maxValue) {
24
    // 桶的长度
25
    int bucketLen = maxValue - minValue + 1;
26
    int[] temp = new int[bucketLen];
27
    // 每个值映射后出现的次数
28
    for (int value : arr) temp[value - minValue]++;
29

30
    int sortedIndex = 0;
31
    for (int j = 0; j < bucketLen; j++) {
32
        while (temp[j] > 0) {
33
            arr[sortedIndex++] = j + minValue; // 把桶中的数取出放到数组末尾
34
            temp[j]--; // 用掉了一次当前数，桶中的次数减少
35
        }
36
    }
37

38
    return arr;
39
}