第十五周项目4 - 英文单词的基数排序

本文介绍了一种使用基数排序算法对英文单词进行字典顺序排列的方法。通过预处理和恢复处理确保所有单词达到统一长度,并利用27个队列进行多趟分配与收集实现排序。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

/*                                           
*Copyright (c) 2017,烟台大学计算机与控制工程学院                                           
*All rights reserved.                                           
*文件名称:项目4-英文单词的基数排列          
*作    者:董丽娟                                           
*完成日期:2017年12月13日                                           
*版 本 号:v1.0                                              
*/         

设计一个基数排序的算法,将一组英文单词,按字典顺序排列。假设单词均由小写字母或空格构成,最长的单词有MaxLen个字母。

代码:

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define MaxLen 9                //单词的最大长度
#define Radix  27               //基数rd为27,分别对应' ','a',…'z'
typedef char String[MaxLen+1];  //定义String为字符数组类型
typedef struct node
{
    String word;
    struct node *next;
} LinkNode;
void DispWord(String R[],int n) //输出单词
{
    int i;
    printf("  ");
    for (i=0; i<n; i++)
        printf("[%s] ",R[i]);
    printf("\n");
}
void PreProcess(String R[],int n)
//对单词进行预处理,用空格填充尾部至MaxLen长
{
    int i,j;
    for (i=0; i<n; i++)
    {
        if (strlen(R[i])<MaxLen)
        {
            for (j=strlen(R[i]); j<MaxLen; j++)
                R[i][j]=' ';
            R[i][j]='\0';
        }
    }
}
void EndProcess(String R[],int n)
//恢复处理,删除预处理时填充的尾部空格
{
    int i,j;
    for (i=0; i<n; i++)
    {
        for (j=MaxLen-1; R[i][j]==' '; j--);
        R[i][j+1]='\0';
    }
}
void Distribute(String R[],LinkNode *head[],LinkNode *tail[],int j,int n)
//按关键字的第j个分量进行分配,进入此过程时各队列一定为空
{
    int i,k;
    LinkNode *p;
    for (i=0; i<n; i++)         //依次扫描R[i],将其入队
    {
        if (R[i][j]==' ')       //空格时放入0号队列中,'a'时放入1号队列中,…
            k=0;
        else
            k=R[i][j]-'a'+1;
        p=(LinkNode *)malloc(sizeof(LinkNode)); //创建新结点
        strcpy(p->word,R[i]);
        p->next=NULL;
        if (head[k]==NULL)
        {
            head[k]=p;
            tail[k]=p;
        }
        else
        {
            tail[k]->next=p;
            tail[k]=p;
        }
    }
}
void Collect(String R[],LinkNode *head[])
//依次将各非空队列中的记录收集起来
{
    int k=0,i;
    LinkNode *p;
    for (i=0; i<Radix; i++)
        for (p=head[i]; p!=NULL; p=p->next)
            strcpy(R[k++],p->word);
}
void RadixSort(String R[],int n)    //对R[0..n-1]进行基数排序
{
    LinkNode *head[Radix],*tail[Radix]; //定义Radix个队列
    int i,j;
    for (i=MaxLen-1; i>=0; i--)             //从低位到高位做d趟箱排序
    {
        for (j=0; j<Radix; j++)
            head[j]=tail[j]=NULL;           //队列置空
        Distribute(R,head,tail,i,n);        //第i趟分配
        Collect(R,head);                    //第i趟收集
    }
}
int main()
{
    int n=6;
    String R[]= {"while","if","if else","do while","for","case"};
    printf("排序前:\n");
    DispWord(R,n);
    PreProcess(R,n);
    printf("预处理后:\n");
    DispWord(R,n);
    RadixSort(R,n);
    printf("排序结果:\n");
    DispWord(R,n);
    EndProcess(R,n);
    printf("最终结果:\n");
    DispWord(R,n);
    printf("\n");
    return 0;
}
运行结果:



知识点总结:

基数排序

<think>我们正在讨论多关键字排序中的LSD(最低位优先)方法。用户要求了解其实现原理或代码。根据引用内容,LSD排序是一种基数排序,它从最低位关键字开始,逐步向最高位关键字进行排序。每次排序都是稳定的,即相同键值的元素在排序后保持原来的相对顺序。实现原理:1.LSD排序从最次位关键字(最低位)开始,依次向最主位关键字(最高位)进行排序。2.对于每个关键字,使用稳定的排序算法(如计数排序)进行排序。3.由于是稳定的排序,在后续的关键字排序中,之前排序的结果(即相同当前关键字的元素在之前关键字上的有序性)得以保持。引用[1]中提供了一段代码片段,展示了对8个记录的LSD排序。引用[2]提到LSD排序是有效的多关键字排序方法,并提到待排序记录数不超过10000,关键字不超过5个,每个关键字范围0-100。引用[3]解释了多关键字排序的词典有序关系,并指出LSD是从最次位关键字到最主位关键字的顺序排序。引用[4]则对比了MSD(最高位优先)和LSD,说明LSD是自后向前逐次排序。因此,我们可以这样实现LSD多关键字排序:-假设有n个记录,每个记录有d个关键字(K0,K1,...,K_{d-1}),其中K0是最主位关键字,K_{d-1}是最次位关键字。-我们按照关键字从最低位(K_{d-1})到最高位(K0)的顺序进行排序。-对每个关键字使用计数排序(因为稳定且适合小范围整数)。下面我们给出一个C语言的实现示例,该示例假设记录的关键字为整数,且关键字范围已知(0到radix-1)。注意,我们使用计数排序作为每一趟的排序算法。实现步骤:1.准备一个临时数组tmp,用于存放中间排序结果。2.从最低位关键字(k=d-1)开始到最高位关键字(k=0),依次执行:a.初始化计数数组cnt(大小为radix+1,初始化为0)。b.统计每个桶(即当前关键字的值)中的记录数。c.将计数数组cnt进行累加,使得cnt[i]表示小于等于i的记录数(这样在放置记录时可以知道位置)。d.从后向前遍历原数组(保证稳定性),根据当前关键字的值,将记录放入tmp数组的相应位置(使用cnt数组计算位置,然后cnt数组相应值减1)。e.将tmp数组的内容复制回原数组(此时原数组按当前关键字排序完成)。3.释放临时空间。注意:由于每一趟排序都是稳定的,所以经过所有关键字的排序后,整个记录序列就是有序的。下面我们给出一个具体的代码实现(基于引用[1]的代码片段进行扩展和注释):</think>### LSD算法在多关键字排序中的实现原理 LSD(最低位优先)是一种基数排序算法,用于多关键字排序场景。其核心思想是**从最低优先级的关键字开始排序,逐步向高优先级关键字推进**,每次排序都使用稳定的排序方法(通常为计数排序)。以下是实现原理: #### 关键步骤 1. **初始化**: - 确定关键字数量 $d$(如日期排序中的年、月、日) - 确定每个关键字的基数范围 $radix$(如月份范围 0-11) 2. **从低位到高位迭代**: ```c for (int k = d-1; k >= 0; k--) // 从最低位关键字开始 { // 对第k个关键字执行计数排序 } ``` 3. **计数排序过程**: - **统计频次**:遍历所有元素,统计当前关键字值的出现次数 ```c int cnt[radix+1] = {0}; for (int i = 0; i < n; i++) cnt[a[i].keys[k] + 1]++; // 计数偏移 ``` - **计算位置**:将计数转换为元素位置索引 ```c for (int i = 1; i <= radix; i++) cnt[i] += cnt[i-1]; // 累加得到分界位置 ``` - **元素重排**:按当前关键字值放入临时数组 ```c for (int i = n-1; i >= 0; i--) { int key = a[i].keys[k]; tmp[--cnt[key+1]] = a[i]; // 稳定排序关键 } ``` - **写回原数组**: ```c for (int i = 0; i < n; i++) a[i] = tmp[i]; ``` #### 算法特性 - **稳定性**:每个关键字的排序都是稳定的,确保之前排序的结果不被破坏 - **时间复杂度**:$O(d \cdot (n + radix))$,当 $d$ 较小且 $radix$ 不大时效率高 - **空间复杂度**:$O(n + radix)$,需要额外空间存储计数数组和临时数组 #### 示例场景 对日期排序(关键字:年、月、日): 1. 先按**日**排序(最低位) 2. 再按**月**排序(中间位) 3. 最后按**年**排序(最高位) > 由于每轮排序都是稳定的,当处理"年"时,同年份的日期仍保持"月-日"的有序性[^3]。 ### 完整C语言实现 ```c #include <stdlib.h> typedef struct { int keys[3]; // 存储3个关键字(如年、月、日) } Record; void LSD_sort(Record* a, int n, int d, int radix) { Record* tmp = (Record*)malloc(n * sizeof(Record)); int* cnt = (int*)calloc(radix+2, sizeof(int)); // 计数数组 for (int k = d-1; k >= 0; k--) { // 从最低位关键字开始 // 初始化计数数组 for (int i = 0; i <= radix+1; i++) cnt[i] = 0; // 统计频次 for (int i = 0; i < n; i++) cnt[a[i].keys[k] + 1]++; // 计算分界位置 for (int i = 1; i <= radix; i++) cnt[i] += cnt[i-1]; // 元素重排(从后向前保证稳定) for (int i = n-1; i >= 0; i--) { int key_val = a[i].keys[k]; tmp[--cnt[key_val + 1]] = a[i]; } // 写回原数组 for (int i = 0; i < n; i++) a[i] = tmp[i]; } free(tmp); free(cnt); } // 使用示例 int main() { Record dates[5] = { {{2023, 7, 15}}, // 年、月、日 {{2022, 5, 20}}, {{2023, 7, 10}}, {{2022, 6, 15}}, {{2023, 8, 1}} }; LSD_sort(dates, 5, 3, 31); // 基数范围:日(0-31) // 排序后:日期按升序排列 return 0; } ``` ### 应用场景 1. **日期/时间排序**:年--日、时--秒等复合结构 2. **词典排序**:单词按字母逐个位置排序 3. **多维度数据**:如学生成绩(班级->学号->分数) 4. **卡片排序机**:传统物理卡片排序的数字实现[^4] > LSD排序要求关键字有明确优先级且取值范围有限,当关键字范围较大时(如字符串),MSD(最高位优先)可能更高效[^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值