【算法设计与分析】排序算法性能分析

b1ngsha

已于 2023-06-08 12:03:48 修改

阅读量469

点赞数 1

分类专栏：算法设计与分析文章标签：排序算法算法数据结构

于 2023-04-02 15:06:13 首次发布

本文链接：https://blog.csdn.net/weixin_62263911/article/details/129910901

版权

算法设计与分析专栏收录该内容

6 篇文章 0 订阅

订阅专栏

实验内容与结果

实现选择排序、冒泡排序、合并排序、快速排序、插入排序算法

以待排序数组的大小n为输入规模，固定n，随机产生20组测试样本，统计不同排序算法在20个样本上的平均运行时间

分别以n=10000, n=20000, n=30000, n=40000, n=50000等等，重复2的实验，画出不同排序算法在20个随机样本的平均运行时间与输入规模n的关系

画出理论效率分析的曲线和实测的效率曲线

现在有10亿的数据（每个数据四个字节），请快速挑选出最大的十个数，并在小规模数据上验证算法的正确性。

实验总结

补充

前言

本文章旨在分享学习经历，如有错误请指正。侵删

实验目的

1.掌握选择排序、冒泡排序、合并排序、快速排序、插入排序算法原理

2.掌握不同排序算法时间效率的经验分析方法，验证理论分析与经验分析的一致性。

实验内容与结果

实现选择排序、冒泡排序、合并排序、快速排序、插入排序算法

选择排序

计算过程：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

伪代码：

SELECTION-SORT(A,n)                     cost    times
for i = 1 to n - 1                      c1      n-1
    minIndex = i                        c2      n-1
    for j = i + 1 to n                  c3      n(n-1)/2
        if A[j] < A[minIndex]           c4      n(n-1)/2
            minIndex = j                c5      ∑ti
    exchange A[i] with A[minIndex]      c6      n

其中 $\sum_{i = 1}^{n}ti$ 表示i固定，j取不同值时，不同的i值下minIndex的更新次数

选择排序的运行时间：

T(n) = c1 * (n-1) + c2 * (n-1) + c3 * n(n-1)/2 + c4 * n(n-1)/2 + c5 * $\sum_{i = 1}^{n}ti$ + c6 * n

对其中ti的取值进行讨论

最好情况：数组已排好序

此时在整个循环测试中，总是有A[j] >= A[minIndex]，因此在每一次循环中都不需要更新minIndex的值，所有的ti均为0

运行时间T(n) = c1* (n-1) + c2* (n-1) + c3* (n-1)n/2 + c4* n(n-1)/2 + c6*n

T(n) 可表示为 an² + bn + c，其中a,b,c依赖于语句代价c

最坏情况：数组已逆序排好

此时在整个循环测试中，总是有A[j] < A[minIndex]，在内层循环中每一次循环都要更新一次minIndex值，ti= 1 + 2 + ··· + n - 1 = n(n-1)/2

运行时间T(n) = c1* (n-1) + c2* (n-1) + c3* (n-1)n/2 + c4* n(n-1)/2 + c5* n(n-1)/2 + c6*n

T(n)可表示为 an² + bn + c，其中a,b,c依赖于语句代价c

平均情况：不同的比较次数等概率出现

ti可以理解为随机变量

E(ti) = (1 + 2 + 3 + ··· + i - 1) / (i - 1) = i / 2

参考最坏情况，T(n)可表示为an² + bn + c，则平均情况下的运行时间仍然是n的二次函数

冒泡排序

计算过程：

每一趟都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面两个相邻的两个数的大小关系，重复此步骤，直到最后一个还没归位的数。

伪代码：

BUBBLE-SORT(A.n)                        cost    times
for end = n to 2                        c1      n-1
    for i = 1 to end - 1                c2      n(n-1)/2
        if A[i] > A[i+1]                c3      n(n-1)/2
            exchange A[i] with A[i+1]   c4      ∑tend

其中 $\sum_{end = 2}^{n} tend$ 表示end取不同值时minIndex的更新次数

冒泡排序的运行时间：

T(n) = c1* n + c2* n(n-1)/2 + c3* (n-1)n/2 + c4* $\sum_{end = 2}^{n} tend$

对其中ti的取值进行讨论

最好情况：数组已排好序

此时在整个循环测试中，总是有A[i] <= A[i+1]，因此不需要将两元素调换，所有的tend均为0

运行时间T(n) = c1* n + c2* n(n-1)/2 + c3* (n-1)n/2

T(n) 可表示为 an² + bn + c，其中a,b,c依赖于语句代价c

最坏情况：数组已逆序排好

此时在整个循环测试中，总是有A[i] >= A[i+1]，在内层循环中每一次循环都要将两元素调换， $\sum_{end = 2}^{n} tend$ = n(n-1)/2

运行时间T(n) = c1* n + c2* n(n-1)/2 + c3* (n-1)n/2- + c4* n(n-1)/2

T(n) 可表示为 an² + bn + c，其中a,b,c依赖于语句代价c

平均情况：不同的比较次数等概率出现

tend理解为随机变量

E(tend) = (1 + 2 + 3 + ··· + end - 1) / (end - 1) = end / 2

参考最坏情况，T(n)可表示为an² + bn + c，则平均情况下的运行时间仍然是n的二次函数

合并排序

计算过程：

把一组n个数的序列，折半分为两个序列，然后再将这两个序列再分，一直分下去，直到分为n个长度为1的序列。然后两两按大小归并。如此反复，直到最后形成包含n个数的一个数组。

伪代码：

MERGE-SORT(A,left,right)                cost    times
mid = left + (right - left) / 2         c1      1
if left < right                         c2      1
    MERGESORT(A,left,mid)               c3      n*T(1)
    MERGESORT(A,mid+1,right)            c4      n*T(1)
    MERGE(A,left,mid,right,result)      c5      n*(logn)
    
MERGE(A,left,mid,right,result)          cost    times
i = left                                c1      1
j = mid + 1                             c2      1
k = 1                                   c3      1
while i <= mid and j <= right           c4      t1
    if arr[i] < arr[j]                  c5      t1-1
        result[k++] = A[i++]            c6      ti
    else                                c7      t1-1
        result[k++] = A[j++]            c8      tj
while i <= mid                          c9      n/2-ti+1
    result[k++] = A[i++]                c10     n/2-ti
while j <= right                        c11     n/2-tj+1
    result[k++] = A[j++]                c12     n/2-tj
for a = 1 to n                          c13     n+1
    A[a+left] = result[a]               c14     n

其中ti表示arr的左半边元素插入result数组的插入次数，tj表示将arr的右半边元素插入数组的插入次数

合并排序的运行时间：

T(n) = c1 + c2 + c3* n* T(1) + c4* n * T(1) + c6* n *logn

可以表示成T(n) = a*nlogn + b，其中a,b取决于语句代价c

快速排序

计算过程：

每次排序的时候设置一个基准点，同时从左右两边开始检索，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。

伪代码：

QUICK-SORT(A,left,right)                cost    times
if left > right                         c1      1
    return                              c2      1
temp = A[left]                          c3      1
i = left                                c4      1
j = right                               c5      1
while i != j                            c6      t
    while A[j] >= temp and i < j        c7      tj
        j--                             c8      tj-1
    while A[i] <= temp and i < j        c9      ti
        i++                             c10     ti-1
    if i < j                            c11     t-1
        exchange A[i] and A[j]          c12     te
A[left] = A[i]                          c13     1
A[i] = temp                             c14     1
QUICK-SORT(A,left,i-1)                  c15     nlogn
QUICK-SORT(A,i+1,right)                 c16     nlogn

其中tj表示指针j向左移动的次数，ti表示指针i向右移动的次数，te表示左右两指针指向的值交换的次数

快速排序的运行时间：

T(n) = c1 + c2 + c3 + c4 + c5 + c6 + c7* tj + c8* (tj-1) + c9* ti + c10* (ti-1) + c11* (t-1) + c12* te + c13 + c14 + c15* nlogn + c16*nlogn

可以表示成T(n) = a*nlogn + b，其中a,b取决于语句代价c

插入排序

计算过程：

对于未排序数据，在一排好序的序列中从后向前扫描，找到相应位置并插入。在从后向前扫描的过程中需要反复将以排序的元素逐步向后移位，为新元素提供插入空间。

伪代码：

INSERTION-SORT(A,n)                     cost    times
for i = 2 to n                          c1      n
    insertVal = A[i]                    c2      n-1
    index = i                           c3      n-1
    j = i - 1                           c4      n-1
    while j > 0 and A[j] > insertVal    c5      ∑ti
        A[j+1] = A[j]                   c6      ∑(ti-1)
        index = j                       c7      ∑(ti-1)
        j--                             c8      ∑(ti-1)
    A[index] = insertVal                c9      n-1

其中 $\sum_{i=2}^{n}ti$ 表示i取不同值时为A[i]寻找位置进行比较的次数

插入排序的运行时间：

T(n) = c1* n + c2* (n-1) + c3* (n-1) + c4* (n-1) + c5* $\sum_{i = 2}^{n}(ti-1)$ + c6* $\sum_{i = 2}^{n}(ti-1)$ + c7 * $\sum_{i = 2}^{n}(ti-1)$ + c8* $\sum_{i = 2}^{n}(ti-1)$ + c9*(n-1)

对其中ti的取值进行讨论

最好情况：数组已排好序

此时在整个循环测试中，总是有A[j] <= insertVal，因此不需要将元素移动，所有的ti均为1

运行时间T(n) = c1* n + c2 * (n-1) + c3* (n-1) + c4* (n-1) + c5 + c9* (n-1)

T(n)可表示为an + b，其中a,b依赖于语句代价c

最坏情况：数组已逆序排好

此时在整个循环测试中，总是有A[j] > insertVal，必须将元素A[i]与整个已排序子数组A[1...j]中的每个元素进行比较， ti= j = i - 1

$\sum_{i = 2}^{n}ti$ = n(n+1)/2 – 1

$\sum_{i = 2}^{n}(ti-1)$ = n(n-1)/2

运行时间T(n) = c1* n + c2* (n-1) + c3* (n-1) + c4* (n-1) + c5* [n(n+1)/2 – 1] + c6* n(n-1)/2+ c7* n(n-1)/2 + c8* n(n-1)/2 + c9*(n-1)

T(n) 可表示为 an2 + bn + c，其中a,b,c依赖于语句代价c

平均情况：不同的比较次数等概率出现

tj理解为随机变量

E(tj) = (1 + 2 + 3 + ··· + j) / j = (1 + j) / 2

参考最坏情况，T(n)可表示为an2 + bn + c，则平均情况下的运行时间仍然是n的二次函数