数据结构第十章排序

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
#include <queue>
#include <set>
#define eps 1e-8
const double PI = acos(-1.0);
const int maxn = 1e5;
const int INF = 1e9;
using namespace std;
void InsertionSort(int A[],int n)
{
    int preidx,curr;
    for(int i = 1; i<n; i++)
    {
        preidx = i-1;
        curr = A[i];
        while(preidx>=0 && A[preidx]>curr)
        {
            A[preidx+1] = A[preidx];
            preidx--;
        }
        A[preidx+1] = curr;
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    int A[n+5];
    for(int i = 0; i<n; i++)
        scanf("%d",&A[i]);
    InsertionSort(A,n);
    for(int i = 0; i<n; i++)
        printf("%d ",A[i]);
    printf("\n");
    return 0;
}

算法分析

•设对象个数为n，则执行n-1趟

•比较次数和移动次数与初始排列有关

•最好情况下：

Ø每趟只需比较 1 次，不移动

Ø总比较次数为 n-1

最坏情况下：第 i 趟比较 i 次，移动 i+1 次

•若出现各种可能排列的概率相同，则可取最好情况和最坏情况的平均情况

•平均情况比较次数和移动次数为(n^2)/4

Ø时间复杂度为 O(n2)

Ø空间复杂度为 O(1)

Ø是一种稳定的排序方法

小结

Ø排序趟数：n个数——n-1趟

Ø比较次数、移动次数——与对象排序码的初始排列有关

Ø比较次数最少n-1次，移动次数最少没有移动

Ø比较次数最多(n+2)(n-1)/2次，移动次数最多(n+4)(n-1)/2

Ø平均比较次数和移动次数——n2/4，时间复杂度为 O(n2)

Ø插入排序的稳定性——稳定

折半插入排序

•在插入 r[i] 时，利用折半查找法寻找 r[i] 的插入位置

void BInsertSort(int A[])
{
    int curr;
    for(int i = 1; i<10; i++)
    {
        int low = 0;
        int high = i-1;
        curr = A[i];
        while(low<=high)
        {
            int mid = (low+high)/2;
            if(curr<A[mid])
                high = mid-1;
            else
                low = mid+1;
        }
        for(int j = i-1; j>=high+1; j--)
            A[j+1] = A[j];
        A[high+1] = curr;

    }
}

算法分析

•折半查找比顺序查找快，所以折半插入排序就平均性能来说比直接插入排序要快

•它所需要的关键码比较次数与待排序对象序列的初始排列无关，仅依赖于对象个数。在插入第 i 个对象时，需要经过 log2i +1 次关键码比较，才能确定它应插入的位置

•当 n 较大时，总关键码比较次数比直接插入排序的最坏情况要好得多，但比其最好情况要差

•在对象的初始排列已经按关键码排好序或接近有序时，直接插入排序比折半插入排序执行的关键码比较次数要少

•折半插入排序的对象移动次数与直接插入排序相同，依赖于对象的初始排列

•减少了比较次数，但没有减少移动次数

•平均性能优于直接插入排序

Ø时间复杂度为 O(n2)

Ø空间复杂度为 O(1)

Ø是一种稳定的排序方法

希尔排序

基本思想

先将整个待排记录序列分割成若干子序列,分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。

子序列的构成不是简单地“逐段分割”，将相隔某个增量dk的记录组成一个子序列，让增量dk逐趟缩短（例如依次取5,3,1）。直到dk＝1为止。

优点：小元素跳跃式前移，最后一趟增量为1时，序列已基本有序，平均性能优于直接插入排序

dk 值较大，子序列中对象较少，速度较快；
dk 值逐渐变小，子序列中对象变多，但大多数对象已基本有序，所以排序速度仍然很快。

void shellSort(int A[],int len)
{
    int i,j;
    int increment = len;//增量
    int key;
    while(increment > 1)//最后在增量为1并且是执行了情况下停止。
    {
        increment = increment/3 + 1;//根据公式
        printf("increment:%d\n",increment);
        for (i = increment; i<len; i++)//从[0]开始，对相距增量步长的元素集合进行修改。
        {
            key = A[i];
            //以下和直接插入排序类似。
            j = i-increment;
            while(j>=0)
            {
                if (key<A[j] )
                {
                    int temp = A[j];
                    A[j] = key;
                    A[j+increment] = temp;
                }
                j = j-increment;
            }
        }
    }
}

算法分析

•时间复杂度是n和d的函数：O(n^1.25）～O（1.6n^1.25）—经验公式

•空间复杂度为 O(1)

•是一种不稳定的排序方法

如何选择最佳d序列，目前尚未解决

Ø最后一个增量值必须为1，无除1以外的公因子

Ø不宜在链式存储结构上实现

10.3交换排序

基本思想

两两比较，如果发生逆序则交换，直到所有记录都排好序为止。

冒泡排序

两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。

冒泡排序步骤

比较第0个数与第1个数，若为逆序，即a[0]>a[1]，则交换；然后比较第1个数与第2个数；以此类推，直至第n-2个数和第n-1个数比较完为止，即第0趟冒泡排序结束。第0趟排序的结果是最大的数被安置在最后一个元素位置上。

对前n-1个数进行第1趟冒泡排序，结果使次大的数被安置在第n-1个元素位置。

如此重复上述过程，共经过n-1趟冒泡排序后，排序结束。

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
#include <queue>
#include <set>
#define eps 1e-8
const double PI = acos(-1.0);
const int maxn = 1e5;
const int INF = 1e9;
using namespace std;
void BubbleSort(int A[],int n)
{
    int t;
    int flag = 1;
    for(int i = 0; i<n-1&&flag; i++)
    {
        flag = 0;
        for(int j = 0; j<n-1-i; j++)
        {
            if(A[j]>A[j+1])
            {
                t = A[j];
                A[j] = A[j+1];
                A[j+1] = t;
                flag = 1;
            }
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    int A[n+5];
    for(int i = 0; i<n; i++)
        scanf("%d",&A[i]);
    BubbleSort(A,n);
    for(int i = 0; i<n; i++)
        printf("%d ",A[i]);
    printf("\n");
    return 0;
}

算法分析

•设对象个数为n

•比较次数和移动次数与初始排列有关

最好情况下：

•只需 1趟排序，比较次数为 n-1，不移动

最坏情况下：

•需 n-1趟排序，第i趟比较n-i次，移动3(n-i)次

•时间复杂度为 O(n2)

•空间复杂度为 O(1)

•是一种稳定的排序方法

快速排序

基本思想

•任取一个元素 (如第一个) 为中心

•所有比它小的元素一律前放，比它大的元素一律后放，形成左右两个子表；

•对各子表重新选择中心元素并依此规则调整，直到每个子表的元素只剩一个

①每一趟的子表的形成是采用从两头向中间交替式逼近法；

②由于每趟中对各子表的操作都相似，可采用递归算法。

void quickSort(int a[],int st,int ed)
{
    if(ed - st <= 0)
        return;
    int key =a[st];
    int low = st;
    int high = ed;
    while(low != high)
    {
        while(low<high && a[high]>=key)
            high--;
        while(low<high && a[low]<=key)
            low++;
        if(low<high)
        {
            int t = a[low];
            a[low] = a[high];
            a[high] = t;
        }

    }
    a[st] = a[low];
    a[low] = key;
    quickSort(a,st,low-1);
    quickSort(a,low+1,ed);
}

算法分析

•可以证明，平均计算时间是O(nlog2n)。

•实验结果表明：就平均计算时间而言，快速排序是我们所讨论的所有内排序方法中最好的一个。

•快速排序是递归的，需要有一个栈存放每层递归调用时参数（新的low和high）。

•最大递归调用层次数与递归树的深度一致，因此，要求存储开销为 O(log2n) 。

•最好：划分后，左侧右侧子序列的长度相同

•最坏：从小到大排好序，递归树成为单支树，每次划分只得到一个比上一次少一个对象的子序列，必须经过 n-1 趟才能把所有对象定位，而且第 i 趟需要经过 n-i 次关键码比较才能找到第 i 个对象的安放位置

时间效率：O(nlog2n) —每趟确定的元素呈指数增加

空间效率：O（log2n）—递归要用到栈空间

稳定性：不稳定 —可选任一元素为支点。

10.4选择排序

基本思想

每一趟在后面 n-i +1个中选出关键码最小的对象, 作为有序序列的第 i 个记录

简单选择排序

void SelectionSort(int A[],int n)
{
    int minidx,t;
    for(int i = 0; i<n-1; i++)
    {
        minidx = i;
        for(int j = i+1; j<n; j++)
        {
            if(A[minidx]>A[j])
            {
                minidx = j;
            }
        }
        t = A[i];
        A[i] = A[minidx];
        A[minidx] = t;
    }
}