内部排序->其它->地址排序(地址重排算法)

文字描述

　　当每个记录所占空间较多，即每个记录存放的除关键字外的附加信息太大时，移动记录的时间耗费太大。此时，就可以像表插入排序、链式基数排序，以修改指针代替移动记录。但是有的排序方法，如快速排序和堆排序，无法实现表排序。这种情况下就可以进行“地址排序”，即另设一个地址向量指示相应记录的位置；同时在排序过程中不移动记录而移动记录地址向量中相应分量的内容。见示意图，(b)是排序结束后的地址向量，地址相连adr[1,…,8]中的值表示排序后的记录的次序，r[adr[1]]为最小记录，r[adr[8]]为最大记录。

　　如果需要的话，可根据adr的值重排记录的物理位置。重排算法如下：

　　比如要根据示意图中的(b)中地址向量重排原记录的话，由于(b)中的adr[1]=6, 则在暂存R(49)后，需要将R(13)从r[6]的位置移动到r[1]。又因为adr[6]=2，则将R(65)从r[2]的位置移至r[6]的位置。同理，将R(27)移至r[2]的位置，此时因adr[4]=1，则之前暂存的R(49)应该放在r[4]的位置上。至此完成一个调整记录位置的小循环，此小循环完成后的记录及地址向量的状态如示意图(c)所示。

 

示意图

 

算法分析

       地址排序不能算是独立的算法，只是在之前讨论的内部排序算法中，另设一个地址向量，用移动地址向量中的分量值代替移动记录而已。

       地址重排算法中，因为每个小循环要暂存一个记录，所以辅助空间为1

       地址重排算法中，除需要暂存的记录外，所有记录均一次到位。而每个小循环至少移动两个记录，则这样的小循环最多n/2个，所以重排算法中至多移动记录[3n/2]次，其时间复杂度为n。

 

代码实现

#include <stdio.h>
#include <stdlib.h>

#define DEBUG

#define EQ(a, b) ((a) == (b))
#define LT(a, b) ((a) <  (b))
#define LQ(a, b) ((a) <= (b))

#define MAXSIZE  100
#define INF         1000000
typedef int KeyType;
typedef char InfoType;
typedef struct{
    KeyType key;
    InfoType otherinfo;
}RedType;

typedef struct{
    RedType r[MAXSIZE+1];
    //地址向量
    int adr[MAXSIZE+1];
    int length;
}SqList;

void PrintList(SqList L){
    int i = 0;
    printf("下标值：");
    for(i=0; i<=L.length; i++){
        printf("[%d] ", i);
    }
    printf("\n关键字：");
    for(i=0; i<=L.length; i++){
        if(EQ(L.r[i].key, INF)){
            printf(" %-3c", '-');
        }else{
            printf(" %-3d", L.r[i].key);
        }
    }
    printf("\n其他值：");
    for(i=0; i<=L.length; i++){
        printf(" %-3c", L.r[i].otherinfo);
    }
    printf("\n地址值：");
    for(i=0; i<=L.length; i++){
        printf(" %-3d", L.adr[i]);
    }
    printf("\n\n");
    return ;
}

//堆采用顺序存储表示
typedef SqList HeapType;

/*
 *已知H->r[s,...,m]中记录的关键字除H->r[s].key之外均满足的定义
 *本函数调整H-r[s]的关键字，使H->r[s,...,m]成为一个大顶堆(对其中
 *记录的关键字而言)
 */
void HeapAdjust(HeapType *H, int s, int m)
{
//    RedType rc = H->r[s];
    RedType rc = H->r[H->adr[s]];
    int rc_adr = H->adr[s];
    int j = 0;
    //沿key较大的孩子结点向下筛选
    for(j=2*s; j<=m; j*=2){
        //j为key较大的纪录的下标
        if(j<m && LT(H->r[H->adr[j]].key, H->r[H->adr[j+1]].key))
            j+=1;
        //rc应该插入位置s上
        if(!LT(rc.key, H->r[H->adr[j]].key))
            break;
        H->adr[s] = H->adr[j];
        s = j;
    }
    //插入
    H->adr[s] = rc_adr;
}

/*
 * 对顺序表H进行堆排序
 */
void HeapSort(HeapType *H)
{
#ifdef DEBUG
    printf("开始堆排序，和之前的堆排序不同之处在于，移动地址向量代替移动记录。\n");
#endif
    int i = 0;
    //把H->r[1,...,H->length]建成大顶堆
    for(i=H->length/2; i>=1; i--){
        HeapAdjust(H, i, H->length);
    }
#ifdef DEBUG
    printf("由一个无序序列建成一个初始大顶堆：\n");
    PrintList(*H);
#endif
    int tmp;
    for(i=H->length; i>1; i--){
        //将堆顶记录和当前未经排序子序列H->r[1,...,i]中最后一个记录相互交换
        tmp = H->adr[1];
        H->adr[1] = H->adr[i];
        H->adr[i] = tmp;
        //将H->r[1,...,i-1]重新调整为大顶堆
        HeapAdjust(H, 1, i-1);
#ifdef DEBUG
        printf("调整1至%d的元素，使其成为大顶堆：\n", i-1);
        PrintList(*H);
#endif
    }
}

/*
 * adr给出顺序表H的有序次序，即L->r[adr[i]]是第i小的记录
 * 本算法按adr重排H，使其有序
 */
void Rearrange(HeapType *H, int adr[])
{
    int i = 0, j =0, k = 0;
    for(i=1; i<=H->length; i++){
        if(adr[i] != i){
            //暂存记录H->r[i]
            H->r[0] = H->r[i];
            j = i;
            //调整L->r[adr[j]]的记录到位直到adr[j] == i为止
            while(adr[j] != i){
                k = adr[j];
                H->r[j] = H->r[k];
                adr[j] = j;
                j = k;
            }
            //记录到序
            H->r[j] = H->r[0];
            adr[j] = j;
#ifdef DEBUG
            printf("第%d躺调整：\n", i);
            PrintList(*H);
#endif
        }
    }
}

int  main(int argc, char *argv[])
{
    if(argc < 2){
        return -1;
    }
    HeapType H;
    int i = 0;
    for(i=1; i<argc; i++){
        if(i>MAXSIZE)
            break;
        H.r[i].key = atoi(argv[i]);
        H.r[i].otherinfo = 'a'+i-1;
        H.adr[i] = i;
    }
    H.length = (i-1);
    H.r[0].key = H.adr[0] = 0;
    H.r[0].otherinfo = '0';
    printf("输入数据:\n");
    PrintList(H);
    //对顺序表H作堆排序
    HeapSort(&H);
#ifdef DEBUG
    printf("对排序后的顺序表按照地址向量重新调整记录位置，使其有序\n");
#endif
    Rearrange(&H, H.adr);
    PrintList(H);
    return 0;
}

 

运行