分类：排序

分类：排序

十大排序方法汇总

关于时间复杂度

平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。
线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；
O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序
线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。
名词解释：
• n：数据规模
• k："桶"的个数
• In-place：占用常数内存，不占用额外内存
• Out-place：占用额外内存
• 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

1、冒泡排序

// 这个方式i表示循环次数
void bsort(int a[], int len) {
    if(len <= 0) return ;
    for(int i = 0; i < len-1; i++) {
        for(int j = 0; j < len-1-i; j++) {
            if(a[j] > a[j+1]) {
                std::swap(a[j], a[j+1]);
            }
        }
    }
}

// 这个方式，i表示要冒出来的位置（推荐）
void b_sort(std::vector<int>& a) {
    if(a.empty()) {
        return ;
    }
    int len = a.size();
    for(int i = len-1; i > 0; i--) {
        for(int j = 0; j < i; j++) {
            if(a[j] > a[j+1]) {
                std::swap(a[j], a[j+1]);
            }
        }
    }
}

2、选择排序

void ssort(int a[], int len) {
    if(len <= 0) return;
    for(int i = 0; i < len-1; i++) {
        int minpos = i;
        for(int j = i+1; j < len; j++) {
            if(a[minpos] > a[j]) {
                minpos = j;
            }
        }
        std::swap(a[minpos], a[i]);
    }
}

3、插入排序

void isort(int a[], int len) {
    if(len <= 0) return ;
    for(int i = 1; i < len; i++) {
        int key = a[i];
        int j = i-1;
        while(j >= 0 && a[j] > key) {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = key;
    }
}

4、希尔排序

void shell_sort(int a[], int len) {
    for(int h = len >> 1; h > 0; h >>= 1) {
        for(int i = h; i < len; i++) {
            int tmp = a[i];
            int j = i - h;
            while(j >= 0 && a[j] > tmp) {
                a[j+h] = a[j];
                j -= h;
            }
            a[j+h] = tmp;
        }
    }
}

5、归并排序

void msort(int a[], int len) {
    if(!a || len<=0) {
        return ;
    }
    int* p1 = a;
    int* p2 = (int*)malloc(len*sizeof(int));
    for(int seg = 1; seg < len; seg*=2) {
        for(int start = 0; start < len; start += seg*2) {
            int mid = std::min(start + seg, len);
            int end = std::min(start + seg*2, len);
            int s1 = start, s2 = mid;
            int k = s1;
            while(s1 < mid && s2 < end) {
                p2[k++] = p1[s1] < p1[s2] ? p1[s1++] : p1[s2++];
            }
            while(s1 < mid) {
                p2[k++] = p1[s1++];
            }
            while(s2 < end) {
                p2[k++] = p1[s2++];
            }
        }
        std::swap(p1, p2);
    }
    if(p2 == a) {
        for(int i = 0; i < len; i++) {
            p2[i] = p1[i];
        }
        p2 = p1;
    }
    free(p2);
}

6、快速排序

#include <iostream>                                                                                             
using namespace std;

void quick_sort(int a[], int low, int high) {
    if(low >= high) return;
    int i = low, j = high;
    int pivot = a[i];
    while(i < j) {
        while(i < j && a[j] >= pivot) j--;
        a[i] = a[j];
        while(i < j && a[i] <= pivot) i++;
        a[j] = a[i];
    }
    a[i] = pivot;
    quick_sort(a, low, i-1);
    quick_sort(a, i+1, high);
}

int main() {
    int a[] = {1, 8, 4, 5, 2};
    quick_sort(a, 0, 4);
    for(int i = 0;i < 5;i++) {
        cout << a[i] << endl;
    }
    return 0;
}

7、堆排序

#include<iostream>

void heapfy(int a[], int index, int heapsize) {
    int left = index*2+1;
    int right = left+1;
    int largest = index;
    if(left < heapsize && a[index] < a[left]) {
        largest = left;
    }
    if(right < heapsize && a[largest] < a[right]) {
        largest = right;
    }
    if(largest != index) {
        std::swap(a[index], a[largest]);
        heapfy(a, largest, heapsize);
    }
}

void makeheap(int a[], int len) {
    for(int i = len/2-1; i >= 0; i--) {
        heapfy(a, i, len);
    }
}

void heapsort(int a[], int len) {
    makeheap(a, len);
    for(int i = len-1; i > 0; i--) {
        std::swap(a[0], a[i]);
        heapfy(a, 0, i);
    }
}

int main()
{
    int a[10] = {9,3,4,5,1,8,0,2,7,6};
    heapsort(a, 10);
    return 0;
}

8、计数排序

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

void print_arr(int *arr, int n) {
        int i;
        printf("%d", arr[0]);
        for (i = 1; i < n; i++)
                printf(" %d", arr[i]);
        printf("\n");
}

void counting_sort(int *ini_arr, int *sorted_arr, int n) {
        int *count_arr = (int *) malloc(sizeof(int) * 100);
        int i, j, k;
        for (k = 0; k < 100; k++)
                count_arr[k] = 0;
        for (i = 0; i < n; i++)
                count_arr[ini_arr[i]]++;
        for (k = 1; k < 100; k++)
                count_arr[k] += count_arr[k - 1];
        for (j = n; j > 0; j--)
                sorted_arr[--count_arr[ini_arr[j - 1]]] = ini_arr[j - 1];
        free(count_arr);
}

int main(int argc, char **argv) {
        int n = 10;
        int i;
        int *arr = (int *) malloc(sizeof(int) * n);
        int *sorted_arr = (int *) malloc(sizeof(int) * n);
        srand(time(0));
        for (i = 0; i < n; i++)
                arr[i] = rand() % 100;
        printf("ini_array: ");
        print_arr(arr, n);
        counting_sort(arr, sorted_arr, n);
        printf("sorted_array: ");
        print_arr(sorted_arr, n);
        free(arr);
        free(sorted_arr);
        return 0;
}

9、桶排序

// C++ program to sort an array using bucket sort
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

// Function to sort arr[] of size n using bucket sort
void bucketSort(float arr[], int n)
{
    // 1) Create n empty buckets
    vector<float> b[n];

    // 2) Put array elements in different buckets
    for (int i=0; i<n; i++)
    {
       int bi = n*arr[i]; // Index in bucket
       b[bi].push_back(arr[i]);
    }

    // 3) Sort individual buckets
    for (int i=0; i<n; i++)
       sort(b[i].begin(), b[i].end());

    // 4) Concatenate all buckets into arr[]
    int index = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < b[i].size(); j++)
          arr[index++] = b[i][j];
}

/* Driver program to test above funtion */
int main()
{
    float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
    int n = sizeof(arr)/sizeof(arr[0]);
    bucketSort(arr, n);

    cout << "Sorted array is \n";
    for (int i=0; i<n; i++)
       cout << arr[i] << " ";
    return 0;
}

10、基数排序

int maxbit(int data[], int n) //辅助函数，求数据的最大位数
{
    int maxData = data[0];              ///< 最大数
    /// 先求出最大数，再求其位数，这样有原先依次每个数判断其位数，稍微优化点。
    for (int i = 1; i < n; ++i)
    {
        if (maxData < data[i])
            maxData = data[i];
    }
    int d = 1;
    int p = 10;
    while (maxData >= p)
    {
        //p *= 10; // Maybe overflow
        maxData /= 10;
        ++d;
    }
    return d;
/*    int d = 1; //保存最大的位数
    int p = 10;
    for(int i = 0; i < n; ++i)
    {
        while(data[i] >= p)
        {
            p *= 10;
            ++d;
        }
    }
    return d;*/
}
void radixsort(int data[], int n) //基数排序
{
    int d = maxbit(data, n);
    int *tmp = new int[n];
    int *count = new int[10]; //计数器
    int i, j, k;
    int radix = 1;
    for(i = 1; i <= d; i++) //进行d次排序
    {
        for(j = 0; j < 10; j++)
            count[j] = 0; //每次分配前清空计数器
        for(j = 0; j < n; j++)
        {
            k = (data[j] / radix) % 10; //统计每个桶中的记录数
            count[k]++;
        }
        for(j = 1; j < 10; j++)
            count[j] = count[j - 1] + count[j]; //将tmp中的位置依次分配给每个桶
        for(j = n - 1; j >= 0; j--) //将所有桶中记录依次收集到tmp中
        {
            k = (data[j] / radix) % 10;
            tmp[count[k] - 1] = data[j];
            count[k]--;
        }
        for(j = 0; j < n; j++) //将临时数组的内容复制到data中
            data[j] = tmp[j];
        radix = radix * 10;
    }
    delete []tmp;
    delete []count;
}