[算法相关]几种常用的排序算法

1. 冒泡排序法

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
冒泡排序的原理如下：
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
例子：
C语言：

#include <stdio.h>

void bubbleSort(int *arr, int len) {
    int isSorted;
    int i = 0, j = 0, tmp = 0;
    for (i = 0; i < len - 1; i++) {
        isSorted = 1;
        for (j = 0; j < len - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                isSorted = 0;
            }
        }

        if (isSorted) {
            break;
        }
    }
}

int main() {
    int arr[] = {1, 5, 1, 5, 3, 2, 2, 9, 8, 9};
    int i, len = sizeof(arr) / sizeof(arr[0]);

    printf("Before sort: ");
    for (i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    bubbleSort(arr, len);

    printf("After  sort: ");
    for (i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");
    return 0;
}

2. 选择排序法

选择排序法是一种不稳定的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

选择排序法的第一层循环从起始元素开始选到倒数第二个元素，主要是在每次进入的第二层循环之前，将外层循环的下标赋值给临时变量，接下来的第二层循环中，如果发现有比这个最小位置处的元素更小的元素，则将那个更小的元素的下标赋给临时变量，最后，在二层循环退出后，如果临时变量改变，则说明，有比当前外层循环位置更小的元素，需要将这两个元素交换。
例子：
C语言：

#include <stdio.h>

void selectSort(int *arr, int len) {
    int i = 0, j = 0, tmp = 0;
    for (i = 0; i < len - 1; i++) {
        for (j = i + 1; j < len; j++) {
            if (arr[j] < arr[i]) {
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

void selectSort2(int *arr, int len) {
    int i = 0, j = 0, tmp = 0;
    for (i = 0; i < len - 1; i++) {
        int min = i;
        for (j = i + 1; j < len; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }

        tmp = arr[min];
        arr[min] = arr[i];
        arr[i] = tmp;
    }
}

int main() {
    int arr[] = {1, 5, 1, 5, 3, 2, 2, 9, 8, 9};
    int i, len = sizeof(arr) / sizeof(arr[0]);

    printf("Before sort: ");
    for (i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    selectSort2(arr, len);

    printf("After  sort: ");
    for (i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");
    return 0;
}

3.快速排序法

快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序算法通过多次比较和交换来实现排序，其排序流程如下：
(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。
(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
(4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。
例子：
C语言：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void quickSort(int *arr, int len) {
    if (len < 2) {
        return;
    }

    int i = 0, num = arr[0];
    int *lessArr = malloc(len * sizeof(int));
    int *middleArr = malloc(len * sizeof(int));
    int *greatArr = malloc(len * sizeof(int));
    int lessArrLen = 0, greatArrLen = 0, middleArrLen = 0;

    for (i = 1; i < len; i++) {
        if (arr[i] < num) {
            lessArr[lessArrLen++] = arr[i];
        } else if (arr[i] > num) {
            greatArr[greatArrLen++] = arr[i];
        } else {
            middleArr[middleArrLen++] = arr[i];
        }
    }

    quickSort(lessArr, lessArrLen);
    quickSort(greatArr, greatArrLen);

    if (lessArrLen > 0) {
        memcpy(arr, lessArr, lessArrLen * sizeof(int));
    }
    arr[lessArrLen] = num;
    if (middleArr > 0)
        memcpy(arr + lessArrLen + 1, middleArr, middleArrLen * sizeof(int));
    if (greatArrLen > 0)
        memcpy(arr + lessArrLen + 1 + middleArrLen, greatArr, greatArrLen * sizeof(int));

    free(lessArr);
    free(greatArr);
}

void quickSort2(int *a, int left, int right) {
    if (left >= right)
        return;

    int key = a[left];
    int i = left;
    int j = right;

    //[i, j]范围内快速查找
    while (i < j) {
        //从右向左找到一比key值小的值，放到key所在的位置，即i的位置
        while (i < j && a[j] >= key) {
            j--;
        }

        a[i] = a[j];

        //从左向右找到一比key值大的值，放到刚才所查到的位置，即j的位置
        while (i < j && a[i] <= key) {
            i++;
        }

        a[j] = a[i];

     }

    //实现了比key值小的值在最左侧，比key值大的值在最右侧，key值在中央
    a[i] = key;
    quickSort2(a, left, i - 1);
    quickSort2(a, i + 1, right);
}

int main() {
    int arr[] = {1, 5, 1, 5, 3, 2, 2, 9, 8, 9};
    int i, len = sizeof(arr) / sizeof(arr[0]);

    printf("Before sort: ");
    for (i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    //quickSort(arr, len);
    quickSort2(arr, 0, len - 1);

    printf("After  sort: ");
    for (i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");
    return 0;
}