快速排序、归并排序、选择排序（时间复杂度、空间复杂度、实际执行时间、实际占用内存空间、每次程序迭代后的数组顺序）

已于 2023-10-29 22:49:36 修改
阅读量113 收藏 1
点赞数
分类专栏： 练习 文章标签： 排序算法 算法
于 2023-10-29 22:47:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62658261/article/details/134109461
版权

#include <stdio.h>  // 引入标准输入输出头文件

#include <stdlib.h>  // 引入标准库头文件

#include <windows.h>  // 引入Windows平台头文件

#include <psapi.h>

// 给定生成随机数的个数,可修改

#define TEST_NUM 10    // 定义一个常量，表示生成随机数的个数

// ANSI 转义序列，用于改变文本颜色

#define ANSI_COLOR_GREEN "\x1b[32m"  // 定义绿色的ANSI转义序列

#define ANSI_COLOR_RESET "\x1b[0m"  // 定义重置颜色的ANSI转义序列

int quicksort_count = 0;  // 定义一个全局变量用于记录快速排序迭代次数

// 定义一个函数来获取当前时间戳（微秒级别）

double get_time() {

    LARGE_INTEGER frequency;  // 定义一个大整数结构体用于存储高精度计数器的频率

    LARGE_INTEGER start_time;  // 定义一个大整数结构体用于存储开始时间

    QueryPerformanceFrequency(&frequency);  // 获取高精度计数器的频率

    QueryPerformanceCounter(&start_time);  // 获取开始时间

    return (double)start_time.QuadPart / (double)frequency.QuadPart;  // 返回当前时间戳（微秒级别）

}

// 快速排序算法

void quicksort(int arr[], int left, int right, int size) {

    if (left < right) {

        int pivot = arr[left];  // 设置基准元素为数组的第一个元素

        int i = left;  // 定义左指针

        int j = right + 1;  // 定义右指针

        while (1) {

            do {

                i++;

            } while (arr[i] < pivot);  // 从左向右找到第一个大于等于基准元素的位置

            do {

                j--;

            } while (arr[j] > pivot);  // 从右向左找到第一个小于等于基准元素的位置

            if (i < j) {

                int temp = arr[i];

                arr[i] = arr[j];

                arr[j] = temp;  // 交换左右两个元素的位置

            }

            else {

                break;

            }

        }

        int temp = arr[left];

        arr[left] = arr[j];

        arr[j] = temp;  // 将基准元素放到正确的位置

        // 打印当前迭代后的数组顺序，并高亮打印交换的两个数

        printf("迭代 %d 次后的数组顺序: ", quicksort_count++);

        for (int k = 0; k < size; k++) {

            if (k == left || k == j) {

                printf(ANSI_COLOR_GREEN "%d " ANSI_COLOR_RESET, arr[k]);

            }

            else {

                printf("%d ", arr[k]);

            }

        }

        printf("\n");

        quicksort(arr, left, j - 1, size);  // 递归处理左边的子数组

        quicksort(arr, j + 1, right, size);  // 递归处理右边的子数组

    }

}

// 归并排序算法

void merge(int arr[], int left, int mid, int right) {

    int i, j, k;

    int n1 = mid - left + 1;  // 计算左子数组的大小

    int n2 = right - mid;  // 计算右子数组的大小

    int* L = (int*)malloc(n1 * sizeof(int));  // 为左子数组分配内存

    int* R = (int*)malloc(n2 * sizeof(int));  // 为右子数组分配内存

    for (i = 0; i < n1; i++) {

        L[i] = arr[left + i];  // 复制左半部分到临时数组L

    }

    for (j = 0; j < n2; j++) {

        R[j] = arr[mid + 1 + j];  // 复制右半部分到临时数组R

    }

    i = 0;

    j = 0;

    k = left;

    while (i < n1 && j < n2) {

        if (L[i] <= R[j]) {

            arr[k] = L[i];

            i++;

        }

        else {

            arr[k] = R[j];

            j++;

        }

        k++;

    }

    while (i < n1) {

        arr[k] = L[i];

        i++;

        k++;

    }

    while (j < n2) {

        arr[k] = R[j];

        j++;

        k++;

    }

    free(L);  // 释放临时数组L的内存

    free(R);  // 释放临时数组R的内存

    for (int k = left; k < right; k++) {

            printf("%d ", arr[k]);

    }

    printf("\n");

}

void merge_sort(int arr[], int left, int right) {

    if (left < right) {

        int mid = left + (right - left) / 2;

        merge_sort(arr, left, mid);  // 递归处理左半部分

        merge_sort(arr, mid + 1, right);  // 递归处理右半部分

        merge(arr, left, mid, right);  // 合并左右两部分

    }

}

// 选择排序算法

void selection_sort(int arr[], int n) {

    int i, j, min_idx;

    for (i = 0; i < n - 1; i++) {

        min_idx = i;

        for (j = i + 1; j < n; j++) {

            if (arr[j] < arr[min_idx]) {

                min_idx = j;

            }

        }

        int temp = arr[i];

        arr[i] = arr[min_idx];

        arr[min_idx] = temp;  // 将当前位置的元素与最小元素进行交换

        // 打印当前迭代后的数组顺序，并高亮打印交换的两个数

        printf("迭代 %d 次后的数组顺序: ", i + 1);

        for (int k = 0; k < n; k++) {

            if (k == i || k == min_idx) {

                printf(ANSI_COLOR_GREEN "%d " ANSI_COLOR_RESET, arr[k]);

            }

            else {

                printf("%d ", arr[k]);

            }

        }

        printf("\n");

    }

}

// 填充随机测试数组

void random_add(int arr1[], int arr2[], int arr3[], int size) {

    for (int i = 0; i < size; i++) {

        arr1[i] = rand() % 1000000000; // 随机数范围0 ≤ x < 10^9

        arr2[i] = arr1[i]; // 复制到arr2

        arr3[i] = arr1[i]; // 复制到arr3

    }

    for (int i = 0; i < size; i++) {

        printf("%d ", arr1[i]); // 打印随机数

    }

}

 //定义printMemoryInfo函数来打印内存使用信息

void printMemoryInfo(HANDLE process) {

    PROCESS_MEMORY_COUNTERS_EX pmc;

    if (GetProcessMemoryInfo(process, (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {

        printf("私有工作集: %llu 字节\n", (ULONGLONG)pmc.PrivateUsage);

        printf("共享工作集: %llu 字节\n", (ULONGLONG)(pmc.WorkingSetSize - pmc.PrivateUsage));

        printf("虚拟内存大小: %llu 字节\n", (ULONGLONG)pmc.PagefileUsage);

    }

}

int main() {

    int arr1[TEST_NUM];

    int arr2[TEST_NUM];

    int arr3[TEST_NUM];

    int size = sizeof(arr1) / sizeof(arr1[0]);

    printf("随机生成的数组如下：\n");

    random_add(arr1, arr2, arr3, size);

    // 快速排序

    printf("\n快速排序：\n");

    double start, end;

    start = get_time();

    // 在排序之前获取和打印内存使用情况

    /*printf("排序前:\n");

    PROCESS_MEMORY_COUNTERS_EX pmc;

    if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {

        printf("私有工作集: %llu 字节\n", (ULONGLONG)pmc.PrivateUsage);

        printf("共享工作集: %llu 字节\n", (ULONGLONG)(pmc.WorkingSetSize - pmc.PrivateUsage));

        printf("虚拟内存大小: %llu 字节\n", (ULONGLONG)pmc.PagefileUsage);

    }*/

    quicksort(arr1, 0, size - 1, size);

    // 在排序之后获取和打印内存使用情况

    /*printf("排序后:\n");

    if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {

        printf("私有工作集: %llu 字节\n", (ULONGLONG)pmc.PrivateUsage);

        printf("共享工作集: %llu 字节\n", (ULONGLONG)(pmc.WorkingSetSize - pmc.PrivateUsage));

        printf("虚拟内存大小: %llu 字节\n", (ULONGLONG)pmc.PagefileUsage);

    }*/

    end = get_time();

    printf("运行时间: %lf seconds\n", (double)(end - start));

    // 归并排序

    printf("\n归并排序：\n");

    start = get_time();

    ///在排序之前获取和打印内存使用情况

    /*printf("排序前:\n");

    if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {

        printf("私有工作集: %llu 字节\n", (ULONGLONG)pmc.PrivateUsage);

        printf("共享工作集: %llu 字节\n", (ULONGLONG)(pmc.WorkingSetSize - pmc.PrivateUsage));

        printf("虚拟内存大小: %llu 字节\n", (ULONGLONG)pmc.PagefileUsage);

    }*/

    merge_sort(arr2, 0, size - 1);

    // 在排序之后获取和打印内存使用情况

    /*printf("排序后:\n");

    if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {

        printf("私有工作集: %llu 字节\n", (ULONGLONG)pmc.PrivateUsage);

        printf("共享工作集: %llu 字节\n", (ULONGLONG)(pmc.WorkingSetSize - pmc.PrivateUsage));

        printf("虚拟内存大小: %llu 字节\n", (ULONGLONG)pmc.PagefileUsage);

    }*/

    end = get_time();

    printf("运行时间: %lf seconds\n", (double)(end - start));

    // 选择排序

    printf("\n选择排序：\n");

    start = get_time();

    ///在排序之前获取和打印内存使用情况

    /*printf("排序前:\n");

    if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {

        printf("私有工作集: %llu 字节\n", (ULONGLONG)pmc.PrivateUsage);

        printf("共享工作集: %llu 字节\n", (ULONGLONG)(pmc.WorkingSetSize - pmc.PrivateUsage));

        printf("虚拟内存大小: %llu 字节\n", (ULONGLONG)pmc.PagefileUsage);

    }*/

    selection_sort(arr3, size);

    // 在排序之后获取和打印内存使用情况

    /*printf("排序后:\n");

    if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {

        printf("私有工作集: %llu 字节\n", (ULONGLONG)pmc.PrivateUsage);

        printf("共享工作集: %llu 字节\n", (ULONGLONG)(pmc.WorkingSetSize - pmc.PrivateUsage));

        printf("虚拟内存大小: %llu 字节\n", (ULONGLONG)pmc.PagefileUsage);

    }*/

    end = get_time();

    printf("运行时间: %lf seconds\n", (double)(end - start));

    return 0;

}

  1. 输入随机生成0≦x≦109数组，长度分别为5、10、100；

5：

10：

100：

  1. 时间复杂度、空间复杂度、实际执行时间、实际占用内存空间

快速排序（Quick Sort）：

时间复杂度：

最优情况：O(n log n)

平均情况：O(n log n)

最坏情况：O(n^2)（当数组已经有序时）

空间复杂度：

最优情况：O(log n)（递归调用栈的深度）

最坏情况：O(n)（当数组已经有序时）

归并排序（Merge Sort）：

时间复杂度：

最优情况：O(n log n)

平均情况：O(n log n)

最坏情况：O(n log n)

空间复杂度：

总体空间复杂度为O(n)，但是因为归并排序是基于分治法的，所以它需要额外的空间来存储临时数组，因此空间复杂度为O(n)。

选择排序（Selection Sort）：

时间复杂度：

最优情况：O(n^2)

平均情况：O(n^2)

最坏情况：O(n^2)

空间复杂度：

O(1)（不需要额外的空间，只需要交换元素的位置）

实际执行时间、实际占用内存空间以10长度为例：

  1. 每次程序迭代后的数组顺序

    研究与思考：分析算法时间复杂性，能否将递归程序非递归化？

    快速排序的非递归版本：

    时间复杂度：

    最优情况：O(n log n)

    平均情况：O(n log n)

    最坏情况：O(n^2)（当数组已经有序时）

    空间复杂度：

    最优情况：O(log n)（栈空间用于存储分割点）

    最坏情况：O(n)（当数组已经有序时）

    归并排序的非递归版本：

    时间复杂度：

    最优情况：O(n log n)

    平均情况：O(n log n)

    最坏情况：O(n log n)

    空间复杂度：

    总体空间复杂度为O(n)，但因为归并排序需要额外的空间来存储临时数组，所以空间复杂度为O(n)。

    选择排序：

    选择排序本身就是一个迭代算法，不需要进行递归化。其时间复杂度和空间复杂度如下：

    时间复杂度：

    最优情况：O(n^2)

    平均情况：O(n^2)

    最坏情况：O(n^2)

    空间复杂度：

    O(1)（不需要额外的空间，只需要交换元素的位置）

可乐加冰884
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
算法介绍——快速排序
人人都懂物联网
10-11 4万+
快速排序 快速排序是最常用的排序算法。 举例说明 假设我们要对 “6 1 2 7 9 3 4 5 10 8” 这 10 个数进行排序。 C代码实现 # 复杂度分析
冒泡、快速、选择、插入排序以及时间复杂度、空间复杂度的解析
八爪大头鱼
08-11 2068
四大排序的时间复杂度和空间复杂度时间复杂度时间复杂度的表示方法时间复杂度的分析和计算方法常见的几种时间复杂度常见的时间复杂度排序空间复杂度 时间复杂度 (1)时间频率 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。 (2
Python算法之『 冒泡、选择、快速排序算法的时间性能比较』
[ta叫我小白]的专栏
06-05 2120
关于冒泡、选择、快速排序算法的Python实现代码，此处不赘述，完整代码请查看： 冒泡排序 选择排序 快速排序 问题1：就这三种排序算法而言，快排是否是最优方案？ 问题2：冒泡和选择的时间复杂度相同，其时间性能表现是否真的相同（或者相差无几）？ 一、在数组的无序程度较高的情况下 下面直接比较它们的时间性能，代码如下： if __name__ == '__main__': import numpy import time t = time.time...
算法的时间复杂度和空间复杂度-总结
热门推荐
zolalad的专栏
09-20 33万+
算法的时间复杂度和空间复杂度 1、时间复杂度 （1）时间频度 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(
根号n段归并排序算法时间复杂度分析过程
10-26
根号n段归并排序算法时间复杂度分析过程： 1.合并 根号n向下取整 段子数组使用的是自底向上两两归并的策略 2.根号n段归并排序算法时间复杂度的数学推导
归并分类与快速分类平均时间之比较的源代码.rar_快速排序 时间
09-21
在对本程序的快速排序和归并排序这两种算法的正确与否进行验证时，用手动输入的数据，本程序基本上完成了对输入数据进行的快速排序和归并排序!
快速排序与归并排序的时间复杂度分析
12-01
排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的...本文主要介绍快速排序算法和归并排序算法的基本概念、原理以及具体的实现方法，并对这两种排序算法的时间复杂度进行分析。
四种排序算法时间记录（C语言实现快排归并插入大顶堆）
04-21
课程实验数据结果，C语言实现快排归并插入大顶堆。 内含5W-50W随机生成整数每隔5W数据量排序一次的时间记录，并对其进行了均值和方差的比较。
冒泡排序 直接选择排序 直接插入排序 随机快速排序 归并排序 堆排序.zip
04-27
直接插入排序的时间复杂度为O(n^2)，其中n是待排序元素的数量。这是因为对于每个待插入元素，都需要进行至多n-1次比较。直接插入排序的空间复杂度为O(1)，因为它不需要额外的存储空间。此外，直接插入排序是稳定的，...
快速排序（Quick_Sort）
2301_76783671的博客
06-09 464
先用一个变量t存储元素，从左右两端循环，因为排序的元素是最左端元素，所以应该先从右侧开始，如果遇到了小于t的元素，就将左侧覆盖为他，接着从左端开始，如果遇到比t大的元素就将他覆盖到右边，直到low == hight；这个时候的位置就是左侧数都小于t，右侧数都大于t，将t插入后返回即可。每次排序一个元素，每次使他的左边都比他小，右边都比他大；先排序low位置的元素。然后返回他排序后的位置。接着排序他左边和右边。递归直到只剩一个元素。
【算法】常用排序算法（插入排序、希尔排序、堆排序、选择排序、冒泡排序、快速排序、归并排序、计数排序）超详细
abcwyffff的博客
06-09 1048
排序算法是数据结构相关知识中非常重要的一节，相信很多小伙伴对这部分知识一知半解。那么接下来，小编就要带领大家一起来进行对排序算法的深入剖析学习，希望本篇文章能够使你有所收获！
C语言题目：排序问题2
一枚学习中的带专生
06-13 306
main函数是程序的入口点，它没有接收任何参数，也没有返回值。在main：一个整型数组，用于存储用户输入的10个整数。int temp;：一个整型变量，用于在排序过程中交换元素。int p = 0;：一个标志变量，用于跟踪每次遍历是否发生了元素交换。
【数据结构】排序——插入排序，选择排序
m0_74091744的博客
06-09 1276
前言本篇博客我们正式开启数据结构中的排序，说到排序，我们能联想到我之前在C语言博客中的冒泡排序，它是排序中的一种，但实现效率太慢，这篇博客我们介绍两种新排序，并好好深入理解排序若有问题 评论区见📝。
排序-快排算法对数组进行排序
Nelson_hehe的博客
06-10 567
java刷题：快排算法实现对数组的排序
【每日刷题】Day63
2301_78022459的博客
06-13 740
【每日刷题】Day63
总结七大排序算法
m0_73629312的博客
06-09 806
直接插入排序是一种简单的插入排序法，其基本思想是：。实际中我们玩扑克牌时，就用了插入排序的思想。
java算法：快速排序
weixin_45832694的博客
06-12 233
在上述代码中，quickSort()方法是快速排序的入口方法，它调用了私有的辅助方法quickSort()和partition()。quickSort()方法通过递归调用对子数组进行排序，而partition()方法用于将数组分区并返回基准元素的最终位置。快速排序是一种常用的排序算法，它利用分治的思想将一个数组分成两个子数组，然后递归地对子数组进行排序，最终将整个数组排序完成。可以看到，快速排序算法成功地对数组进行了排序。快速排序的平均时间复杂度为O(nlogn)，其中n是数组的长度。
java算法：冒泡排序
最新发布
weixin_45832694的博客
06-13 422
然而，尽管这些优化方法可以减少比较和交换的次数，冒泡排序的时间复杂度仍然是O(n^2)，因此对于大规模数据集来说，并不是最优的排序算法选择。传统的冒泡排序是从左到右逐个比较并交换相邻元素的位置，而鸡尾酒排序是交替进行从左到右和从右到左的遍历，将较大的元素从末端冒泡到首端，再将较小的元素从首端冒泡到末端。在每一趟遍历中，通过记录最后一次交换的位置，将该位置作为下一趟遍历的边界。为了优化冒泡排序，可以引入一个标志变量来记录是否发生了交换操作，如果某一趟遍历中没有发生交换，就说明数组已经有序，可以提前结束排序。
快速排序，堆排序，归并排序 最好时间复杂度 最坏时间复杂度 平均时间复杂度 空间复杂度
11-29
快速排序： 最好时间复杂度：O(nlogn) 最坏时间复杂度：O(n²) 平均时间复杂度：O(nlogn) 空间复杂度：O(logn) ```python def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right) ``` 堆排序： 最好时间复杂度：O(nlogn) 最坏时间复杂度：O(nlogn) 平均时间复杂度：O(nlogn) 空间复杂度：O(1) ```python def heapify(arr, n, i): largest = i l = 2 * i + 1 r = 2 * i + 2 if l < n and arr[i] < arr[l]: largest = l if r < n and arr[largest] < arr[r]: largest = r if largest != i: arr[i], arr[largest] = arr[largest], arr[i] heapify(arr, n, largest) def heap_sort(arr): n = len(arr) for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) for i in range(n - 1, 0, -1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) return arr ``` 归并排序： 最好时间复杂度：O(nlogn) 最坏时间复杂度：O(nlogn) 平均时间复杂度：O(nlogn) 空间复杂度：O(n) ```python def merge_sort(arr): if len(arr) <= 1: return arr mid = len(arr) // 2 left = merge_sort(arr[:mid]) right = merge_sort(arr[mid:]) return merge(left, right) def merge(left, right): result = [] i = j = 0 while i < len(left) and j < len(right): if left[i] < right[j]: result.append(left[i]) i += 1 else: result.append(right[j]) j += 1 result += left[i:] result += right[j:] return result ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值