成都工业学院数据结构与算法（DSA）实验八：排序技术

写在前面

1、基于2021级计算机类实验指导书

2、代码仅提供参考

3、如果代码不满足你的要求，请寻求其他的途径

4、所用时间因为太短了捕捉不到，所有大多数情况显示为0，当元素数量扩大到5000这样的级别后，时间就会变得明显

运行环境

window11家庭版

CLion 2023.2.2

实验要求、源代码和运行结果

1、A数组中存储500个2000以内的随机整数，完成以下操作：

（1）对A数组中的元素进行直接插入排序，显示排序所用时间；

（2）对A数组中的元素进行希尔排序，显示排序所用时间；

（3）对A数组中的元素进行起泡排序，显示排序所用时间；

（4）对A数组中的元素进行快速排序，显示排序所用时间。

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

// 直接插入排序
void insertionSort(int arr[], int n)
{
    for (int i = 1; i < n; i++)
    {
        int key = arr[i];
        int j = i - 1;

        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

// 希尔排序
void shellSort(int arr[], int n)
{
    for (int gap = n/2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < n; i += 1)
        {
            int temp = arr[i];

            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
                arr[j] = arr[j - gap];

            arr[j] = temp;
        }
    }
}

// 冒泡排序
void bubbleSort(int arr[], int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 快速排序
int partition(int arr[], int low, int high)
{
    int pivot = arr[high];
    int i = (low - 1);

    for (int j = low; j <= high - 1; j++)
    {
        if (arr[j] < pivot)
        {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return (i + 1);
}

void quickSort(int arr[], int low, int high)
{
    if (low < high)
    {
        int pi = partition(arr, low, high);

        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main()
{
    const int SIZE = 500;
    const int MAX_NUM = 2000;
    int arr[SIZE];

    srand(time(0));
    for (int i = 0; i < SIZE; i++)
    {
        arr[i] = rand() % MAX_NUM + 1;
    }

    cout << "原始数组：" << endl;
    for (int i = 0; i < SIZE; i++)
    {
        cout << arr[i] << " ";
        if ((i + 1) % 20 == 0)
            cout << endl;
    }
    cout << endl;

    // 直接插入排序
    clock_t start = clock();
    insertionSort(arr, SIZE);
    clock_t end = clock();
    double time_taken = double(end - start) / CLOCKS_PER_SEC;
    cout << "直接插入排序所用时间：" << time_taken << "秒" << endl;

    // 希尔排序
    start = clock();
    shellSort(arr, SIZE);
    end = clock();
    time_taken = double(end - start) / CLOCKS_PER_SEC;
    cout << "希尔排序所用时间：" << time_taken << "秒" << endl;

    // 冒泡排序
    start = clock();
    bubbleSort(arr, SIZE);
    end = clock();
    time_taken = double(end - start) / CLOCKS_PER_SEC;
    cout << "冒泡排序所用时间：" << time_taken << "秒" << endl;

    // 快速排序
    start = clock();
    quickSort(arr, 0, SIZE - 1);
    end = clock();
    time_taken = double(end - start) / CLOCKS_PER_SEC;
    cout << "快速排序所用时间：" << time_taken << "秒" << endl;

    cout << "所有排序后的数组均相同，如下所示：" << endl;
    for (int i = 0; i < SIZE; i++)
    {
        cout << arr[i] << " ";
        if ((i + 1) % 20 == 0)
            cout << endl;
    }

    return 0;
}