常见排序算法

一、冒泡排序。冒泡排序是最简单的一种排序算法。其基本原理是在设有n个元素的数据集中，第一个元素与第二个元素比较，小数放前面大数放后面。然后第二个元素与第三个元素比较，小数放前面大数放后面。。。比较到第n个元素得到n个元素中的最大值，然后在n-1个元素中重复以上过程，得到n-1个元素中的最大值。。。直到排序完成。时间复杂度为O(n^2)。

void bubbleSort(int a[]) {
    for (int i = 16; i > 1; i--) {
        for (int j = 15; j > 16 - i; j--) {
            m++;
            if (a[j] > a[j - 1]) {
                a[j] += a[j - 1];
                a[j - 1] = a[j] - a[j - 1];
                a[j] = a[j] - a[j - 1];
            }
        }
    }
}

二、简单插入排序：将一个记录插入到已经排好序的有序表中，从而形成一个新的、记录数增1的有序表。时间复杂度O(n^2)。

void insertSort(int a[]) {
    for (int i = 1; i < 4; i++) {
        for (int j = i; j < 4; j++) {
            if (a[j - 1] > a[j]) {
                a[j - 1] += a[j];
                a[j] = a[j - 1] - a[j];
                a[j - 1] = a[j - 1] - a[j];
            }
        }
    }
}

三、希尔排序：缩小增量排序，一种改进后的插入排序算法。

void shellInsertSort(int a[], int len) {
    // 外层循环，缩小增量
    for (int step = len / 2; step >= 1; step = step / 2) {
        // 内层两个for循环做插入排序
        for (int i = 0; i < step; i++) {
            for (int j = i + step; j < len; j++) {
                if (a[j - step] > a[j]) {
                    a[j - step] += a[j];
                    a[j] = a[j - step] - a[j];
                    a[j - step] = a[j - step] - a[j];
                }
            }
        }
    }
}

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

/**
 * 归并排序中的分解与合并操作
 * @param a
 * @param start
 * @param midInd
 * @param end
 */
void merge(int a[], int start, int midInd, int end) {//start<=midInd<end
    int n1 = midInd - start + 1;
    int n2 = end - midInd;

    // 分解
    int L[100];
    int R[100];
    for (int i = 0; i < n1; i++) {//将子数组a[p……q]复制到L中
        L[i] = a[start + i];
    }
    for (int i = 0; i < n2; i++) {//将子数组a[q+1……r]复制到R中
        R[i] = a[midInd + i + 1];
    }

    if (n1 + n2 <= 1) return;

    // 合并两个子序列
    int i = 0;
    int j = 0;
    for (int k = start; k <= end; k++) {
        if ((j == n2 || L[i] <= R[j]) && i < n1) {// 此处可以不使用哨兵
            a[k] = L[i];
            i++;
        } else if ((i == n1 || L[i] > R[j]) && j < n2) {
            a[k] = R[j];
            j++;
        }
    }
}

/**
 * 归并排序，二路归并
 * @param a
 */
void mergeSort(int a[], int start, int end) {

    if (start < end) {
        int midInd = (end + start) / 2;
        mergeSort(a, start, midInd);
        mergeSort(a, midInd + 1, end);
        merge(a, start, midInd, end);
    }
}

五、快速排序：在数组中选取一个分界值，讲比分界值大的元素放在右边，比分界值晓得元素放左边，并对左右两边的子数组进行上述操作。重复以上过程，通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

void quickSort(int a[], int start, int end) {
    if (start >= end) return;
    int midVal = a[start];
    int mid = start;
    int rightInd = end;
    int i = 0;
    for (i = start + 1; i < rightInd; i++) {
        if (a[i] <= midVal) {
            a[mid] = a[i];
            mid++;
        } else {
            a[rightInd] += a[i];
            a[i] = a[rightInd] - a[i];
            a[rightInd] = a[rightInd] - a[i];
            rightInd--;
            i--;
        }
    }
    a[mid] = midVal;
    if (a[i] <= midVal) {
        a[mid] = a[i];
        a[i] = midVal;
        mid++;
    }

    quickSort(a, start, mid - 1);
    quickSort(a, mid + 1, end);
}

六、堆排序：每次构造一个大根或小根堆并输出堆得根节点便可以得到一个有序数列。以大根堆为例：

/**
 * 构造大根堆
 * @param a
 * @param len
 */
void buildHeap(int a[], int len) {
    for (int i = len / 2 - 1; i >= 0; i--) {
        n++;
        int largestIndex = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        if (left < len && a[largestIndex] < a[left]) {
            largestIndex = left;
        }
        if (right < len && a[largestIndex] < a[right]) {
            largestIndex = right;
        }
        if (largestIndex != i) {
            int t = a[largestIndex];
            a[largestIndex] = a[i];
            a[i] = t;
        }
    }
}

/**
 * 堆排序
 * @param a
 */
void heapSort(int a[], int len) {

    while (true) {
        buildHeap(a, len);
        a[0] += a[--len];
        a[len] = a[0] - a[len];
        a[0] = a[0] - a[len];
        if (len <= 1) break;
    }
}

七、计数排序：

/**
 *
 * 计数排序
 * 一种非比较排序算法，可以看作一种特殊的桶排序算法
 * 1、有限偏序集S
 * 2、待排序数组a中的元素均属于偏序集S
 * 3、遍历数组a，S[a[i]] ++
 * 4、遍历有限偏序集S，将S下标i输出S[i]次
 * @param a
 * @param len
 */
void countSort(int a[], int len) {
    // 有限偏序集
    int S[10] = {0};

    for (int i = 0; i < len; i++) {
        S[a[i]]++;
    }

    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < S[i]; j++) {
            std::cout << i << " ";
        }
    }
    std::cout << std::endl;
}

八、桶排序：

/**
 * 桶排序
 * 一种非比较排序算法
 * 算法思路：找出数组案中的最大值和最小值max和min.然后基于某种映射函数f = a[i]/B[0].length 将待排序的关键字a[i]放入第j个桶中（即数组B
 * 的下标j）那么关键字a[i]就是B[j]中元素（每个桶B[j]都是大小为(max-min+1)/(√len+1)的序列），然后对各个桶中的元素进行比较排序。再依次
 * 枚举输出B[0]-B[M]中的全部内容即是一个有序序列
 * @param a
 * @param len
 */
void bucketSort(int a[], int len) {
    int max = a[0], min = a[0];
    for (int i = 1; i < len; i++) {
        if (min > a[i]) {
            min = a[i];
        }
        if (max < a[i]) {
            max = a[i];
        }
    }

    int k = int(sqrt(len));
    int bucketSize = (max - min + 1) / (k + 1);
    std::vector<int> B[k + 2];
    for (int i = 0; i < len; i++) {
        int j = (a[i] - min) / bucketSize;
        B[j].push_back(a[i]);
    }

    for (int j = 0; j <= k + 1; j++) {
        std::vector<int> bucket = B[j];
        // 此处使用插入排序进行单桶排序
        for (int i = 1; i < bucket.size(); i++) {
            for (int x = i; x >= 1; x--) {
                if (bucket.at(x - 1) > bucket.at(x)) {
                    int t = bucket[x - 1];
                    bucket[x - 1] = bucket[x];
                    bucket[x] = t;
                }
            }
        }
        for (int i = 0; i < bucket.size(); i++) {
            std::cout << bucket[i] << " ";
        }
    }
    std::cout << std::endl;
}

九、基数排序：

/**
 * 基数排序,LSD法（Least Significant Digit first以低位为基底进行分配，也就是从个位开始）
 * 1、将待排序数列a以个位数为基底放入0-9个桶中，再将桶中的数字串接起来
 * 2、再以十位为基底进行1操作直到最高位
 * 另有MSD法，与LSD相反以高位为基底进行分配
 * @param a
 * @param len
 */
void radixLSDSort(int a[], int len) {
    std::vector<int> bucket[10];
    int y = 1;

    while (true) {
        for (int i = 0; i < len; i++) {
            int pow10y = int(pow(10, y));
            int index = (a[i] % pow10y) * 10 / pow10y;
            bucket[index].push_back(a[i]);
        }

        if(bucket[0].size() == len){ // 如果所有元素都放入到0号桶中结束迭代
            return;
        }

        int k = 0;
        for (int j = 0; j < 10; j++) {
            int size = bucket[j].size();
            for (int x = 0; x < size; x++) {
                a[k] = bucket[j].at(x);
                k++;
            }
            bucket[j].clear(); // 重置桐子
        }
        y++;
    }
}