基数排序

最新推荐文章于 2024-08-27 13:40:18 发布
最新推荐文章于 2024-08-27 13:40:18 发布
阅读量270 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Hello_World_LVLcoder/article/details/72934546
版权

//RadixSort.h

#ifndef _RADIXSORT_H_
#define _RADIXSORT_H_

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "List\List.h"

#define SIZE	15


typedef int Element;
typedef Element ListType[SIZE];

void CreateRandom(ListType L, int n);
void print(ListType L, int n);

//基数排序
void RadixSort(ListType L, int n);

#endif //_RADIXSORT_H_

//RadixSort.c 

#include "RadixSort.h"

void CreateRandom(ListType L, int n)
{
	int i = 0;
	srand((unsigned)time(NULL));

	for (i = 0; i < n; ++i)
	{
		L[i] = rand() % 0x7F;
	}
}

void print(ListType L, int n)
{
	int i = 0;
	for (i = 0; i < n; ++i)
	{
		printf("%d\t", L[i]);
	}
	printf("\n");
}

/******************************************************
基数排序不需要无序序列直接进行关键字间的比较，而是根据每个关
键字的的信息再借助桶(桶间有序)对各序列中的元素按照一定的关系
进行分配(类似哈希表)，分配到桶上再收集(由于桶间本身有序，且分
配的关系一定，必然分配到桶上的序列按照一定的方式去查看也是有
序的)时必然也是按一定的方式有序，对每个关键字重复分配收集过程
后排序完成。

分配后的收集时，注意先入先出以保证稳定性
为保证可扩展性，应使用链式存储结构作为桶
******************************************************/
static int GetKey(Element L, int p)					//求某个位置p上的关键字
{
	int val = 0;

	while (p >= 0)
	{
		val = L % 10;
		L /= 10;
		p--;
	}
	return val;
}

static void Distribute(ListType L, List list[10], int p, int n)
{
	int i = 0, pos = 0;
	for(i = 0; i < n; ++i)				//对所有元素按照关键字进行分配
	{
		pos = GetKey(L[i], p);
		push_back(&list[pos], L[i]);	
	}
}

static void Collect(ListType L, List list[10])
{
	int i = 0, j = 0, len = 0, k = 0;
	List *p = NULL;

	for (i = 0; i < 10; ++i)			//按桶的顺序收集元素，收集完成后，无序序列对关键字有序
	{
		p = &list[i];
		len = length(*p);
		for (k = 0; k < len; ++k)
			pop_front(p, &L[j++]);
	}
}

void RadixSort(ListType L, int n)
{
	int i = 0, j = 0, m = 0;
	Element Temp;
	List list[10];					//由于是10进制的数字，每个位上只可能是0~9, 所以采用10个链表作为桶

	for(i = 0; i < 10; ++i )
	{
		init(&list[i]);				//初始化
	}

	for(i = 0; i < n; ++i)			//在序列中查找最大元素
	{
		if( L[j] < L[i] )
			j = i;
	}

	Temp = L[j];
	while (Temp > 0)				//计算最大数的最高位，以得到关键字个数
	{
		Temp /= 10;
		m++;
	}

	for(j = 0; j < m; ++j)			//LSD 最低位优先
	{
		Distribute(L, list, j, n);	//按照关键字对序列中每个元素进行分配
		Collect(L, list);			//依照通的顺序收集元素
	}
}

//main.c 

#include "RadixSort.h"

int main(int argc, char **argv)
{
	ListType List ={ 0 };
	int n = sizeof(List) / sizeof(Element);

	CreateRandom(List, n);
	printf("排序前\n");
	print(List, n);

	RadixSort(List, n);
	
	printf("排序后\n");
	print(List, n);

	system("pause");
	return 0;
}

//List.h 

/***************************************** 
头插      尾插      显示      头删      尾删       
按值插入    按位置插入       查找      长度               
逆序      清除      摧毁      初始化 排序 
按位置删除       按值删除 
****************************************/  
  
  
#ifndef LIST_H_  
#define LIST_H_  
#include <stdio.h>  
#include <stdbool.h>
  
typedef int ElementType;  
  
  
typedef struct Node  
{  
    ElementType data;  
    struct Node *next;  
}Node, *pNode;  
  
typedef struct List  
{  
    Node *first;    //指向头结点  
    Node *last;     //指向最后一个节点,用于在某些时候避免不必要的遍历  
    int   size;     //链表除头结点的个数  
}List, *pList;  
  
  
bool init(List *mylist);  
bool push_front(List *mylist, ElementType e);  
bool push_back(List *mylist, ElementType e);  
bool show(List mylist);  
bool pop_front(List* mylist, ElementType *e);  
bool pop_back(List* mylist, ElementType *e);  
bool insert_val(List *mylist, ElementType e);  
bool insert_pos(List *mylist, int i, ElementType e);  
Node *find(List mylist, ElementType e, bool precursor);  
int  length(List mylist);  
bool reverse(List *mylist);  
bool clear(List *mylist);  
bool destroy(List *mylist);  
bool sort(List *mylist);  
bool delete_pos(List *mylist, int i, ElementType *e);  
bool delete_val(List *mylist, ElementType e);  
  
#endif //LIST_H_

//List.c 

#include "List.h"  
#include "stdlib.h"  
/************************* 
在操作线性表时，注意每个结构体成员的值 
注意边界条件，如涉及删除操作，必然先判断链表成员情况 
按位插入时考虑位置、等 
另外注意不同线性表各自的不同特性对操作的影响 
稍加修改便可实现泛型数据结构 
代码中有很多重复的代码片段，可以将它们单独封装成内联函数并在需要时调用。。。。。 
**************************/  
bool init(List *mylist)  
{  
    mylist->last = mylist->first = (Node *)malloc(sizeof(Node));  
    if( NULL == mylist->first )  
    {  
        return false;  
    }  
    mylist->first->next = NULL;   //注意新节点的指针域  
    mylist->first->data = -1;  
    mylist->size = 0;  
    return true;  
}  
  
bool push_front(List *mylist, ElementType e)  
{  
    Node *p = (Node *)malloc(sizeof(Node));  
    if( NULL == p )  
        return false;  
    p->next = NULL;  
    p->data = e;  
  
    p->next = mylist->first->next;  
    mylist->first->next = p;  
    if( 0 == mylist->size )    
        mylist->last = p;    //链表为空时，新节点也是尾节点  
    mylist->size++;  
    return true;  
}  
  
bool push_back(List *mylist, ElementType e)  
{  
    Node *s = NULL;  
    Node *p = (Node *)malloc(sizeof(Node));  
    if( NULL == p )  
        return false;  
    p->data = e;  
    p->next = NULL;  
  
    mylist->last->next = p;         
    mylist->last = p;            //注意更改尾指针  
    mylist->size++;  
    return true;  
}  
  
bool show(List mylist)  
{  
    Node *p = mylist.first->next;  
    while(NULL != p)  
    {  
        printf("%d->", p->data);  
        p = p->next;  
    }  
    printf("NULL\n");  
    printf("尾节点的值为%d\n", *mylist.last);  
    return true;  
}  
  
bool pop_front(List* mylist, ElementType *e)  
{  
    if( 0 == mylist->size)   //避免删除空表  
    {  
        return false;  
    }  
    Node *p = mylist->first->next;  
    mylist->first->next = p->next;  
    *e = p->data;  
    free(p);  
  
    if( 1== mylist->size )       //亦可通过比较p与last指针判断  
        mylist->last = mylist->first; //处理尾指针  
    mylist->size--;  
    return true;  
}  
  
bool pop_back(List* mylist, ElementType *e)  
{  
    if( 0 == mylist->size )  //避免删除空表  
    {  
        printf("链表为空\n");  
        return false;  
    }  
    Node *p = mylist->first;  
    while(p->next != mylist->last)  
        p = p->next;             //寻找尾节点前驱节点  
  
    *e = mylist->last->data;  
    free(mylist->last);  
    mylist->last = p;  
    p->next = NULL;  
    mylist->size--;  
    return true;  
}  
  
bool insert_val(List *mylist, ElementType e)    //此函数的先决条件:链表中已存在节点值必须有序  
{  
    if( 0 == mylist->size )  
        return push_back(mylist, e);  
    Node *v = (Node *)malloc(sizeof(Node));  
    if( NULL == v )  
        return false;  
    v->next = NULL;  
    v->data = e;  
  
    Node *p = mylist->first;  
    while(NULL != p->next && p->next->data < e)  
        p = p->next;       
    if( NULL == p->next )  
        mylist->last = p;        //尾指针  
    v->next = p->next;  
    p->next = v;  
    mylist->size++;  
    return true;  
}  
  
//指定头结点为第0个位置,在第1个位置插入，则插入完成后的第1个位置即为新节点  
bool insert_pos(List *mylist, int i, ElementType e)  
{  
    if( i < 1 )  
    {  
        printf("输入位置小于1， 已插入为第一个节点\n");  
        return push_front(mylist, e);  
    }  
    if( i > mylist->size )  
    {  
         printf("输入的位置大于链表范围，已插入为尾节点\n");  
         return push_back(mylist, e);  
    }  
  
    Node *v = (Node *)malloc(sizeof(Node));  
    if( NULL == v )  
        return false;  
    v->data = e;  
    v->next = NULL;  
  
    Node *p = mylist->first;  
    for(int j = 1; j < i; j++)  
    {  
        p = p->next;     //寻找合适的位置  
    }  
    v->next = p->next;  
    p->next = v;  
    mylist->size++;  
    return true;  
}  
  
Node  *find(List mylist, ElementType e, bool precursor) //precursor为真时返回e节点的前驱节点指针值  
{  
    if( 0 == mylist.size )  
        return NULL;  
    Node *p = mylist.first;  
    while(NULL != p->next && p->next->data != e)  
        p = p->next;  
    if( NULL == p->next )  
        return NULL;  
    else  
        return precursor ? p : p->next;  
}  
  
int  length(List mylist)  
{  
    return mylist.size;  
}  
  
//将链表分成两个链表(链表1有头结点与1节点，链表2为剩余节点的链表)后，将链表2的节点逐个头插入链表1  
bool reverse(List *mylist)  
{  
    if( 0 == mylist->size || 1 == mylist->size )  
        return true;  
    Node *p = mylist->first->next;  
    Node *q = p->next;  
  
    p->next = NULL;      //拆分链表  
    mylist->last = p;    //处理尾指针  
  
    while(NULL != q)  
    {  
        p = q;  
        q = q->next;  
        p->next = mylist->first->next;  
        mylist->first->next = p;  
    }  
    return true;  
}  
  
bool clear(List *mylist)  
{  
    if( 0 == mylist->size )  
        return true;  
    Node *p = mylist->first->next;  
    mylist->last = mylist->first; //尾指针  
    while( NULL != p)  
    {  
        mylist->first->next = p->next;  
        free(p);  
        p = mylist->first->next;  
    }  
    mylist->size = 0;            //！！！  
    return true;  
}  
  
bool destroy(List *mylist)  
{  
    clear(mylist);  
    free(mylist->first);  
    mylist->first = mylist->last = NULL;  
    return true;  
}  
//拆分后按序插入  
bool sort(List *mylist)  
{  
    if( 0 == mylist->size || 1 == mylist->size )  
        return true;  
    Node *p = mylist->first->next;  
    Node *q = p->next;  
    mylist->last = p;    //尾指针  
    p->next = NULL;      //拆分链表  
    Node *s = mylist->first; //s指向含头结点链表  
  
    while(NULL != q)    //q指向不含头结点链表  
    {  
        while(NULL != s->next && s->next->data < q->data)      
        {  
            s = s->next;  
        }  
        if( NULL == s->next )      
            mylist->last = q;    //处理尾指针  
        p = q;    
        q = q->next;  
        p->next = s->next;  
        s->next = p;  
        s = mylist->first;       //!!!!!!!!!!!!!!!!!!!!  
    }  
    return true;  
}  
  
bool delete_pos(List *mylist, int i, ElementType *e)  
{  
    int j = 0;  
    Node *p = mylist->first;  
    Node *q = NULL;  
    if( 0 == mylist->size )  
    {  
        printf("链表为空\n");  
        return false;  
    }  
    if( i < 1 || i > mylist->size )  
    {  
        printf("指定的 删除位置不合法，请重新选择\n");  
        return false;  
    }  
    for(j = 1; j < i; j++)  
    {  
        p = p->next;  
    }  
    q = p->next;  
    p->next = q->next;  
    *e = q->data;  
    if( NULL == q )  
        mylist->last = p;        //  尾  
    free(q);  
    mylist->size--;  
    return true;  
}  
  
bool delete_val(List *mylist, ElementType e)  
{  
    Node * p = NULL, *q = NULL;  
    if( NULL == ( p = find(*mylist, e, true)) )  
    {  
        printf("需要删除的节点不存在\n");  
        return false;  
    }  
    q = p->next;  
    p->next = q->next;  
    if( NULL == q )  
        mylist->last = p;        //  尾  
    free(q);  
    mylist->size--;  
    return true;  
}


基数排序详解
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-27 1374
在计算机科学中，排序算法是一种非常基础和重要的算法类型，用于对一系列数据进行有序的排列。在众多排序算法中，基数排序以其独特的工作机制和优秀的性能，得到了广泛的关注和应用。本文将详细介绍基数排序的相关知识，包括其工作原理、稳定性、优化方法以及应用场景等。
基数排序——详解
最新发布
w_w_wwwww的博客
01-20 936
基数排序（英语：Radix sort）是一种非比较型的排序算法，最早用于解决卡片排序的问题。基数排序将待排序的元素拆分为个关键字，逐一对各个关键字排序后完成对所有元素的排序。如果是从第关键字到第关键字顺序进行比较，则该基数排序称为 MSD（Most Significant Digit first）基数排序；如果是从第关键字到第关键字顺序进行比较，则该基数排序称为 LSD（Least Significant Digit first）基数排序。
(十七）排序算法-基数排序
zhufei463738313的博客
04-13 3423
（1）基数排序（radix sort）属于“分配式排序”，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用。（2）基数排序是属于稳定性的排序，基数排序法是效率高的稳定性排序法。（3）基数排序是桶排序的扩展。（4）基数排序是1887年赫尔曼.何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。
十大经典排序算法详解(三)-堆排序,计数排序,桶排序,基数排序
热门推荐
lovely__RR的博客
02-02 4万+
十大经典排序算法-堆排序,计数排序,桶排序,基数排序 1-堆排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 2-计数排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 3-桶排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 4-基数排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: ...
基数排序算法及优化（java）
weixin_43841461的博客
08-27 907
基数排序是一种非比较排序算法，适用于整数或字符串等类型的排序。通过合理选择按位排序和稳定排序的方法，可以大大提高基数排序的效率。无论是在理论研究还是实际工程中，基数排序都是一个值得深入了解的重要算法。
了解基数排序算法
zsx0728的博客
03-17 492
文章目录基数排序如何工作？基数排序算法C示例复杂度基数排序应用参考文档     在本教程中，您将学习基数排序的工作方式。此外，您还将找到C语言的示例。     基数排序是一种排序技术，它首先将相同位置的各个数字分组，从而对元素进行排序。然后，根据元素的递增/递减顺序对元素进行排序。     假设我们有一个由8个元素组成的数组。首先，我们将根据个位的值对元素进行排序。然后，我们将根据十位的值对元素进行排序。这个过程一直持续到最后一个有效的数位。     初始数组为 [121、432、564、23、1、45、7
基数排序算法
ccc369639963的博客
01-20 1147
基数排序算法 在学会计数排序算法的基础上，本节我们再学习一种排序算法，称为基数排序算法。 基数排序算法适用于对多个整数或者多个字符串进行升序或降序排序，例如： 121, 432, 564, 23, 1, 45, 788 “zhangsan”、“lisi”、“wangwu” 一个整数由多个数字组成，例如 123 由 1、2、3 这 3 个数字组成；一个字符串由多个字符组成，例如 “lisi” 由 “l”、“i”、“s”、“i” 这 4 个字符组成。基数排序算法的实现思路是：对于待排序序列中的各个元素，依次比较
基数排序分析
kashine的博客
12-31 2745
一个整数由多个数字组成，例如 123 由 1、2、3 这 3 个数字组成；一个字符串由多个字符组成，例如 "lisi" 由 "l"、"i"、"s"、"i" 这 4 个字符组成。基数排序算法的实现思路是：对于待排序序列中的各个元素，依次比较它们包含的各个数字或字符，根据比较结果调整各个元素的位置，最终就可以得到一个有序序列。取决于数据范围和数据的位数。非比较型整数排序算法。多个整数或者多个字符串。
基数排序链表c语言,基数排序
weixin_29224589的博客
05-22 808
C++radix sort基数排序的实现算法完整源码(定义，实现，main函数测试)#include///forcollectionoffunctions#include///foramacrocalledassertwhichcanbeusedtoverifyassumptions#include算法学习笔记4 基数排序2021-05-16 23:30...
经典算法:基数排序的小例子
01-01
基数排序(Radix sort)是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于...
C++实现基数排序的方法详解
12-31
基数排序(Radix sort)是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于...
C语言中数据结构之链式基数排序
01-01
C语言中数据结构之链式基数排序 实现效果图： 实例代码： #include #include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 typedef int Status; typedef int ...
c语言实现基数排序解析及代码示例
12-26
基数排序（radixsort）属于“分配式排序”（distributionsort），又称“桶子法”（bucketsort）或binsort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用。 2.基数排序...
2-3查找树的插入与删除
早起的虫儿灬
05-21 7240
本片博客前面部分截取自算法(第4版) 定义:   查找: 要判断一个键是否存在树中，先将它和根节点中的键比较，如果它和其中任意一个相等，查找命中；否则就根据比较的结果找到指向相应区间的连接，并在其指向的子树中递归地继续查找，如果找到了空连接上，查找未命中。 插入: 插入之前，先要对2-3树进行一次未命中的查找: 1、  向2-节点中插入新键 如果未命中查找结束于一个
AVL Tree概念之旋转
早起的虫儿灬
05-01 3710
在探寻AVL Tree旋转这一概念之前，需要弄清楚的一些概念:     1、二叉搜索树（BinarySearch Tree）:若树的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树(Reference to 二叉搜索树)         2、An AVL treeis a self-ba
AVL树删除
早起的虫儿灬
05-16 3695
AVL Tree与BST 由于AVL树本身就是一颗自平衡的BST，因此其的删除比起BST仅仅多了删除后平衡的调整   查找: AVL树中一定不存在两个值大小相同的节点 从AVL树根开始向下搜索，根据意图删除值与当前节点值大小关系进行下一步操作: 1、  当前节点值大于意图删除值，保存当前节点并在当前节点的左子树中继续查找意图删除值 2、  当前节点值小于意图删除值，保存当前节点并在当
定长字符串
早起的虫儿灬
04-07 1930
//SString.h //字符串的定长顺序存储方式，数组内部存储以'\0'结尾的一串字符 #ifndef _SSTRING_H_ #define _SSTRING_H_ #include #include #include #define STRINGLENGTH 20 typedef unsigned char UCHAR; typedef UCHAR SString[STRI
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值