HLG 1030 Sort Problem【堆排序+基数排序】

题意： 从小到大排序

分析：

堆排序讲解：

“堆”定义
　　n个关键字序列Kl，K2，…，Kn称为（Heap），当且仅当该序列满足如下性质（简称为堆性质）： 　　(1)ki<=k(2i）且ki<=k(2i+1)(1≤i≤ n），当然，这是小根堆，大根堆则换成>=号。//k(i）相当于二叉树的非叶结点，K(2i）则是左孩子，k(2i+1）是右孩子 　　若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树： 

树中任一非叶结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字。 

大根堆和小根堆：根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最小者的堆称为小根堆，又称最小堆。根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最大者，称为大根堆，又称最大堆。注意：①堆中任一子树亦是堆。②以上讨论的堆实际上是二叉堆（Binary Heap），类似地可定义k叉堆。

堆的高度
　　堆可以被看成是一棵树，结点在堆中的高度可以被定义为从本结点到叶子结点的最长简单下降路径上边的数目；定义堆的高度为树根的高度。我们将看到，堆结构上的一些基本操作的运行时间至多是与树的高度成正比，为O（lgn）。

堆排序
　　堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单。 　　（1）用大根堆排序的基本思想 　　① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区 　　② 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key 　　③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。 　
…… 
直到无序区只有一个元素为止。 

（2）大根堆排序算法的基本操作： 　　① 初始化操作：将R[1..n]构造为初始堆； 　　② 每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆（亦称重建堆）。 　　注意： 　　①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。 　　②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止

特点
　　堆排序（HeapSort）是一树形选择排序。堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系（参见二叉树的顺序存储结构），在当前无序区中选择关键字最大（或最小）的记录

堆排序与直接选择排序的区别
　　直接选择排序中，为了从R[1..n]中选出关键字最小的记录，必须进行n-1次比较，然后在R[2..n]中选出关键字最小的记录，又需要做n-2次比较。事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行了这些比较操作。 　　堆排序可通过树形结构保存部分比较结果，可减少比较次数。

算法分析
　　堆[排序的时间，主要由建立初始]堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。 　　堆排序的最坏时间复杂度为O(nlogn)。堆序的平均性能较接近于最坏性能。 　　由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。 　　堆排序是就地排序，辅助空间为O(1）， 　　它是不稳定的排序方法。

code:（大根堆）

#include<stdio.h>
#include<string.h>
int a[100002];
int N;
void swap(int &p,int &q)
{
    int t=p;
    p=q;
    q=t;
}
void down(int i,int n)                       //  i<=n/2说明 a[i]为分支结点
{
    int son;
    for(;i<=n/2;i=son)                      //看看新的位置是否已经稳定，不稳定继续下沉
    {
        son=i<<1;
        if((son!=n)&&a[son+1]>a[son])
            son=son+1;
        if(a[son]>a[i])                     //  和大的儿子做比较
            swap(a[son],a[i]);
    }
}
void heap_sort()
{
    int i;
    for(i=N/2;i>=1;i--)    //初始堆建立，从最后一个分支结点开始

        down(i,N);    
    for(i=N;i>=1;i--)      //每次循环首先使堆顶元素和首元素交换，再将首元素下沉到合适的位置，每次实际堆中元素减 1
    {
        swap(a[1],a[i]);   //最大的放到末尾
         down(1,i-1);
    }
}
int main()
{
    int i;
    while(scanf("%d",&N)!=EOF)
    {
        for(i=1;i<=N;i++)
            scanf("%d",&a[i]);
        heap_sort();
        for(i=1;i<=N;i++)
            printf("%d\n",a[i]);
    }
    return 0;
}

 

 

基数排序：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#define clr(x) memset(x,0,sizeof(x))
const int maxn = 100005;
int a[maxn];
int s[10][maxn];
int tp[10];
int main()
{
    int n, i, j, k, w, ls;
    while (scanf("%d",&n)!=EOF)
    {
        for (i=0; i<n; i++)
            scanf("%d",&a[i]);
        clr(tp);
        k = 0, w = 1;
        while (w <= 100000){
            for (i=0; i<n; i++){
                ls = (a[i]/w)%10;
                s[ls][tp[ls]++] = a[i];
            }
            for (i=0; i<10; i++){
                if (tp[i]){
                    for (j=0; j<tp[i]; j++)
                        a[k++] = s[i][j];
                    tp[i] = 0;
                }
            }
            k = 0, w *= 10;
        }
        for (i=0; i<n; i++)
            printf("%d\n",a[i]);
    }
    return 0;
}