排序算法(C++)

原文出处:排序算法总结

#include "stdafx.h"
#include <iostream>
#include <time.h>
using namespace std;
/**1. 冒泡排序*/
//时间复杂度为O(N ^ 2)，空间复杂度为O(1)。排序是稳定的
void bubble_sort(int arr[], int len){
    //每次从后往前冒一个最小值，且每次能确定一个数在序列中的最终位置
    for (int i = 0; i < len - 1; i++){         //比较n-1次
        bool exchange = true;               //冒泡的改进，若在一趟中没有发生逆序，则该序列已有序
        for (int j = len - 1; j >i; j--){    // 每次从后边冒出一个最小值
            if (arr[j] < arr[j - 1]){       //发生逆序，则交换
                swap(arr[j], arr[j - 1]);
                exchange = false;
            }
        }
        if (exchange){
            return;
        }
    }
}
/**2. 插入排序*/
//时间复杂度为O(N^2)，空间复杂度为O(1)。算法是稳定的
void insert_sort(int arr[], int len){
    //每次把当前的数往前插入，可以顺序插入，改进的可以进行二分插入
    for (int i = 1; i < len; i++){
        if (arr[i] < arr[i - 1]){      //发生逆序，往前插入
            int temp = arr[i];
            int j;
            for (j = i - 1; j >= 0 && arr[j]>temp; j--){
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = temp;
        }
    }
}

void insert_binary_sort(int arr[], int len){
    //改进的插入排序，往前插入比较时，进行二分查找
    for (int i = 1; i < len; i++){
        if (arr[i] < arr[i - 1]){
            int temp = arr[i];
            int low = 0, high = i - 1, mid;
            while (low <= high){
                mid = (low + high) / 2;
                if (temp < arr[mid]){
                    high = mid - 1;
                }
                else{
                    low = mid + 1;
                }
            }
            for (int j = i; j >low; j--){
                arr[j] = arr[j - 1];
            }
            arr[low] = temp;
        }
    }
}

/**3. 希尔排序*/
void shell_sort(int arr[], int len){
    //每次选择一个gap，对相隔gap的数进行插入排序
    for (int gap = len / 2; gap > 0; gap /= 2){
        for (int i = 0; i < len; i = i + gap){
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && temp < arr[j - gap]; j -= gap){
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

/**4. 选择排序*/
void select_sort(int arr[], int len){
    //每次从后边选择一个最小值
    for (int i = 0; i < len - 1; i++){     //只需选择n-1次
        int min = i;
        for (int j = i + 1; j < len; j++){
            if (arr[min]>arr[j]){
                min = j;
            }
        }
        if (min != i){
            swap(arr[i], arr[min]);
        }
    }
}

/**5. 快速排序*/
//快速排序
int partition(int arr[], const int left, const int right){
    //对序列进行划分，以第一个为基准
    int pivot = arr[left];
    int pivotpos = left;
    for (int i = left + 1; i <= right; i++){
        if (arr[i] < pivot){
            pivotpos++;
            if (pivotpos != i){     //如果交换元素就位于基准后第一个，则不需要交换
                swap(arr[i], arr[pivotpos]);
            }
        }
    }
    arr[left] = arr[pivotpos];
    arr[pivotpos] = pivot;
    return pivotpos;
}
void quick_sort(int arr[], const int left, const int right){
    if (left < right){
        int pivotpos = partition(arr, left, right);
        quick_sort(arr, left, pivotpos - 1);
        quick_sort(arr, pivotpos + 1, right);
    }
}
void quick_sort(int arr[], int len){
    quick_sort(arr, 0, len - 1);
}

int improve_partition(int arr[], int left, int right){
    //基准进行随机化处理
    int n = right - left + 1;
    srand(time((unsigned)0));
    int gap = rand() % n;
    swap(arr[left], arr[left + gap]);  //把随机化的基准与左边进行交换
    //再从左边开始进行
    return partition(arr, left, right);
}
void quick_improve_sort(int arr[], const int left, const int right){
    //改进的快速排序
    //改进的地方：1、在规模较小时采用插入排序
    //2、基准进行随机选择
    int M = 5;
    if (right - left < M){
        insert_sort(arr, right - left + 2);
    }
    if (left >= right){
        return;
    }
    int pivotpos = improve_partition(arr, left, right);
    quick_improve_sort(arr, left, pivotpos - 1);
    quick_improve_sort(arr, pivotpos + 1, right);
}
void quick_improve_sort(int arr[], int len){
    quick_improve_sort(arr, 0, len - 1);
}

/**6. 归并排序*/
//归并排序
void merge(int arr[], int temp_arr[], int left, int mid, int right){
    //简单归并：先复制到temp_arr，再进行归并
    for (int i = left; i <= right; i++){
        temp_arr[i] = arr[i];
    }
    int pa = left, pb = mid + 1;
    int index = left;
    while (pa <= mid && pb <= right){
        if (temp_arr[pa] <= temp_arr[pb]){
            arr[index++] = temp_arr[pa++];
        }
        else{
            arr[index++] = temp_arr[pb++];
        }
    }
    while (pa <= mid){
        arr[index++] = temp_arr[pa++];
    }
    while (pb <= right){
        arr[index++] = temp_arr[pb++];
    }
}
void merge_improve(int arr[], int temp_arr[], int left, int mid, int right){
    //优化归并：复制时，俩头小，中间大，一次比较完
    for (int i = left; i <= mid; i++){
        temp_arr[i] = arr[i];
    }
    for (int i = mid + 1; i <= right; i++){
        temp_arr[i] = arr[right + mid + 1 - i];
    }
    int pa = left, pb = right, p = left;
    while (p <= right){
        if (temp_arr[pa] <= temp_arr[pb]){
            arr[p++] = temp_arr[pa++];
        }
        else{
            arr[p++] = temp_arr[pb--];
        }
    }
}
void merge_sort(int arr[], int temp_arr[], int left, int right){
    if (left < right){
        int mid = (left + right) / 2;
        merge_sort(arr, temp_arr, 0, mid);
        merge_sort(arr, temp_arr, mid + 1, right);
        merge(arr, temp_arr, left, mid, right);
    }
}

void merge_sort(int arr[], int len){
    int *temp_arr = (int*)malloc(sizeof(int)*len);
    merge_sort(arr, temp_arr, 0, len - 1);
}

/**7. 堆排序*/
void shiftDown(int arr[], int start, int end){
    //从start出发到end，调整为最大堆
    int dad = start;
    int son = dad * 2 + 1;
    while (son <= end){
        //先选取子节点中较大的
        if (son + 1 <= end && arr[son] < arr[son + 1]){
            son++;
        }
        //若子节点比父节点大，则交换，继续往子节点寻找；否则退出
        if (arr[dad] < arr[son]){
            swap(arr[dad], arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
        else{
            break;
        }
    }
}
void heap_sort(int arr[], int len){
    //先调整为最大堆，再依次与第一个交换，进行调整，最后构成最小堆
    for (int i = (len - 2) / 2; i >= 0; i--){   //len为总长度，最后一个为len-1,所以父节点为    (len-1-1)/2
        shiftDown(arr, i, len - 1);
    }
    for (int i = len - 1; i >= 0; i--){
        swap(arr[i], arr[0]);
        shiftDown(arr, 0, i - 1);
    }
}

/**8. 基数排序*/
int maxbit(int data[], int n)
{
    int d = 1;
    for (int i = 0; i<n; i++)
    {
        int c = 1;
        int p = data[i];
        while (p / 10)
        {
            p = p / 10;
            c++;
        }
        if (c>d)
            d = c;
    }
    return d;
}

void RadixSort(int data[], int n)
{
    int count[10];
    int tmp[10];
    int d = maxbit(data, n);
    int r = 1;
    for (int i = 0; i<d; i++)
    {

        for (int i = 0; i<10; i++)//装桶之前要先清桶
            count[i] = 0;
        for (i = 0; i<n; i++) //记录每个桶的记录数
        {
            int k = data[i] / r;
            int q = k % 10;
            count[q]++;
        }
        for (i = 1; i<10; i++)//计算位置
        {
            count[i] += count[i - 1];
            //cout<<count[i]<<" ";
        }
        for (int j = n - 1; j >= 0; j--)
        {
            int p = data[j] / r;
            int s = p % 10;
            tmp[count[s] - 1] = data[j];
            count[s]--;
            //cout<<data[j]<<" ";
        }
        for (i = 0; i<n; i++)
        {
            data[i] = tmp[i];
            //cout<<tmp[i]<<" ";
        }
        //    cout<<endl;
        r = r * 10;

    }

}
int main()
{

    int arr[] = { 1, 3, 5, 4, 2, 1, 9,19,18,17,16,19};
    int len = 7;
    for (int i = 0; i < len; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
    RadixSort(arr, len);
    for (int i = 0; i < len; i++){
        cout << arr[i] << " ";
    }
    system("pause");
    return 0;
}