八大排序算法概述及实现

/************************************************************************/
/*                        八大排序算法概述及实现                            */
/*                                                                      */
/*                               |- 冒泡排序                              */
/*                   -  交换排序 -|                                       */
/*                  |            |- 快速排序                              */
/*                  |                                                   */
/*                  |            |- 插入排序                              */
/*                  |   插入排序 -|                                       */
/*                  |            |- 希尔排序                              */
/*         排序算法 -|                                                    */
/*                  |            |- 选择排序                              */
/*                  |   选择排序 -|                                       */
/*                  |            |- 堆排序                                */
/*                  |                                                    */
/*                  |   归并排序                                          */
/*                  |                                                    */
/*                   -  基数排序                                          */
/*                                                                       */
/*************************************************************************/

#include <iostream>
#include <cstring>
using namespace std;

/************************************************************************/
/*                              冒泡排序                                 */
/************************************************************************/
void bubbleSort(int* arr, int len)
{
    int temp = 0;
    for (int i = 0; i < len - 1; i++) //排序len-1次
    {
        for (int j = 0; j < len - i - 1; j++) //每次找到当前范围内的最大值
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

/************************************************************************/
/*                              快速排序                                 */
/************************************************************************/
void quikSort(int* arr, int left, int right)
{
    if (left < right)
    {
        int i = left, j = right, x = arr[i];
        while (i < j)
        {
            while (i < j&&x <= arr[j])
                j--;
            if (i < j)
                arr[i++] = arr[j];

            while (i < j&&x >= arr[i])
                i++;
            if (i < j)
                arr[j--] = arr[i];
        }
        arr[i] = x;
        quikSort(arr, 0, i - 1);
        quikSort(arr, i + 1, right);
    }
}

/************************************************************************/
/*                              插入排序                                 */
/************************************************************************/
void insertSort(int* arr, int len)
{
    int temp;
    for (int i = 1; i < len; i++) //从第2个数开始
    {
        for (int j = i - 1; j >= 0; j--)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

/************************************************************************/
/*                              希尔排序                                 */
/************************************************************************/
void shellSort(int* arr, int len)
{
    int d = len / 2, temp;
    while (d >= 1)
    {
        for (int i = d; i < len; i++)
        {
            for (int j = i - d; j >= 0; j -= d)
            {
                if (arr[j] > arr[j + d])
                {
                    temp = arr[j];
                    arr[j + d] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        d /= 2;
    }
}

/************************************************************************/
/*                              选择排序                                 */
/************************************************************************/
void selectSort(int* arr, int len)
{
    int id, temp;
    for (int i = 0; i < len - 1; i++) //进行len-1次选择
    {
        id = 0;
        for (int j = 0; j < len - i; j++) //找到最大数据的位置
            if (arr[j] > arr[id])
                id = j;

        temp = arr[id];
        arr[id] = arr[len - i - 1];
        arr[len - i - 1] = temp;
    }
}

/************************************************************************/
/*                                堆排序                                 */
/************************************************************************/
//调整结点
void adjustNode(int* arr, int len, int n)
{
    int l, r, max, temp;
    l = 2 * n + 1;
    r = 2 * n + 2;
    max = n;

    if (l < len&&arr[n] < arr[l])
        max = l;
    if (r < len&&arr[n] < arr[r])
        max = r;

    if (max != n)
    {
        temp = arr[n];
        arr[n] = arr[max];
        arr[max] = temp;
        
        adjustNode(arr, len, max);
    }
}

//建立堆
void makeHeap(int* arr, int len)
{
    for (int i = len / 2; i >= 0; i--)
        adjustNode(arr, len, i);
}

//堆排序
void heapSort(int* arr, int len)
{
    makeHeap(arr, len);

    int temp;
    for (int i = len - 1; i >= 0; i--)
    {
        temp = arr[i];
        arr[i] = arr[0];
        arr[0] = temp;

        adjustNode(arr, i, 0);
    }
}

/************************************************************************/
/*                              归并排序                                 */
/************************************************************************/
//将数组中的两个局部有序序列合并（temp数组中的内存足够）
void mergeArray(int* arr, int first, int mid, int last, int temp[])
{
    int i = first, j = mid + 1;
    int m = mid, n = last;
    int k = 0;

    while (i <= m && j <= n)
    {
        if (arr[i] <= arr[j])
            temp[k++] = arr[i++];
        else
            temp[k++] = arr[j++];
    }

    while (i <= m)
        temp[k++] = arr[i++];

    while (j <= n)
        temp[k++] = arr[j++];

    for (i = 0; i < k; i++)
        arr[first + i] = temp[i];
}

//归并排序
void mergeSort(int* arr, int first, int last, int temp[])
{
    if (first < last)
    {
        int mid = (first + last) >> 1;
        mergeSort(arr, first, mid, temp);
        mergeSort(arr, mid + 1, last, temp);
        mergeArray(arr, first, mid, last, temp);
    }
}

/************************************************************************/
/*                              基数排序                                 */
/************************************************************************/
//计算数组中所有数据的最大位数
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 arr[], int n)
{
    int* tmp = new int[10];
    int* count = new int[10];

    int d = maxbit(arr, 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 = arr[i] / r;
            int q = k % 10;
            count[q]++;
        }
        for (i = 1; i < 10; i++)//计算位置
        {
            count[i] += count[i - 1];
        }
        for (int j = n - 1; j >= 0; j--) //将排序后的结果存到tmp中
        {
            int p = arr[j] / r;
            int s = p % 10;
            tmp[count[s] - 1] = arr[j];
            count[s]--;
        }
        for (i = 0; i < n; i++)
        {
            arr[i] = tmp[i];
        }
        r = r * 10;
    }

    delete[] tmp;
    delete[] count;
}

//打印数组
void printArr(int* arr, int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << arr[i] << ' ';
    }
    cout << endl;
}

int main()
{
    int num, temp;

    cout << "请输入待排序的序列（格式：序列长度n 数1 数2 ... 数n），以回车符结束输入：" << endl;
    cin >> num;
    int* parr = new int[num];
    int* parr0 = new int[num];
    int* ptemp = new int[num]; //辅助内存
    for (int i = 0; i < num; i++)
    {
        cin >> temp;
        parr[i] = temp;
    }
    memcpy(parr0, parr, sizeof(int)*num);

    cout << "
请选择排序方法：
";
    cout << "0 原数组序列； 1 冒泡排序； 2 快速排序； 3 插入排序； 4 希尔排序；
";
    cout << "5 选择排序； 6 堆排序；  7 归并排序； 8 基数排序;  非数字结束！
";
    int id;
    while (cin >> id)
    {
        switch (id)
        {
        case 0:
            memcpy(parr, parr0, sizeof(int)*num);
            break;
        case 1:
            memcpy(parr, parr0, sizeof(int)*num);
            bubbleSort(parr, num);
            break;
        case 2:
            memcpy(parr, parr0, sizeof(int)*num);
            quikSort(parr, 0, num - 1);
            break;
        case 3:
            memcpy(parr, parr0, sizeof(int)*num);
            insertSort(parr, num);
            break;
        case 4:
            memcpy(parr, parr0, sizeof(int)*num);
            shellSort(parr, num);
            break;
        case 5:
            memcpy(parr, parr0, sizeof(int)*num);
            selectSort(parr, num);
            break;
        case 6:
            memcpy(parr, parr0, sizeof(int)*num);
            heapSort(parr, num);
            break;
        case 7:
            memcpy(parr, parr0, sizeof(int)*num);
            mergeSort(parr, 0, num - 1, ptemp);
            break;
        case 8:
            memcpy(parr, parr0, sizeof(int)*num);
            radixSort(parr, num);
            break;
        default:
            break;
        }
        printArr(parr, num);

        cout << "
请选择排序方法：";
    }

    printArr(parr, num);

    delete[] parr;
    delete[] parr0;
    delete[] ptemp;
}