基数排序

【基数排序】十大排序算法之基数排序 【基数排序】十大排序算法之基数排序,是属于【稳定】的排序。 阅读详情

//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;  
}  


Halcon 20.11在WPF中的交互式绘图:完整实现矩形ROI的创建、拖动与坐标获取 本文详细介绍了如何在WPF框架下利用Halcon 20.11实现交互式矩形ROI的创建、拖动与坐标获取。通过HDrawingObject和HSmartWindowControlWPF控件,开发者可以高效构建机器视觉应用,提升项目实战中的开发效率。文章涵盖环境配置、事件处理、坐标获取及性能优化等关键内容。 阅读详情

相关推荐

APK静态分析(取证角度)——理论部分

APP是指应用程序(Application),是指能够在手机、平板电脑、电脑等移动设备上运行的软件。APP可以帮助用户进行各种功能操作,如社交媒体、游戏、购物、学习、工作等。用户可以通过应用商店或者在线下载安装APP,然后在设备上使用它们。APP的种类非常丰富,能够满足用户不同的需求和兴趣。

currify的博客 3211

什么是基数排序?

文章目录什么是基数排序稳定的计数排序基数排序的实现 什么是基数排序 稳定的计数排序 数据结构与算法 | 计数排序 计数排序的基本思路在这里就不多进行介绍了,如果不了解的可以看看我以前写的博客。 void countSort(vector<int>& arr) { int max = arr[0], min = arr[0]; //找出最大值和最小值,缩减范围 for(int i = 1; i < arr.size(); i++) {

凌桓丶的博客 1万+

自动驾驶仿真(六)—— SIL软件在环仿真测试

自动驾驶仿真六—— SIL软件在环仿真测试1. 在环仿真测试2. SIL软件在环仿真测试2.1 模型配置参数2.2 S function生成实现2.3 结果对比3. 参考学习的书目教材 博主前面的博文已经简要介绍了Carsim、Prescan 与 Simulink 在 “V”型开发流程的一些应用,现今成熟的汽车控制系统软件都是以(Model Based Design,MBD)来开发,它以图形化的方式表达复杂的逻辑、代码可读性、可移植性、开发调试便利程度都大大增强,同时利用成熟的代码生成工具链,也避免了手工代

zhudj08的博客 8660

基数排序与链式基数排序

折腾数据结构实验的时候遇到这一个算法。之前对此不甚了解,总算也找到一篇不错的文章。转载如下   基数排序 (Radix Sort) 基数排序是采用“分配”与“收集”的办法,用对多关键码进行排序的思想实现对单关键码进行排序的方法。 多关键码排序: 1.以扑克牌排序为例。每张扑克牌有两个“关键码”:花色和面值。其有序关系为: 花色: 面值:2 2.如果我们把所有扑克牌排成以下

atskyline 1万+

【MCU开发规范】:车载MCU开发规范

车载MCU开发规范

1052

基于分段线性近似的Softmax硬件加速器设计

本文深入探讨了基于分段线性近似的Softmax硬件加速器设计。针对深度学习模型中Softmax函数在硬件实现时指数运算成本高昂的问题,提出用分段线性拟合替代传统泰勒展开,通过一次乘加操作高效完成计算,并详细分析了输入范围压缩、精度与硬件资源权衡、以及包含地址生成、参数查找、乘加计算和归一化的完整硬件架构。该方法在保证精度的同时,显著提升了AI边缘芯片的推理速度和能效。

weixin_28278377的博客 313

基数排序--链式基数排序(Radix)

链式基数排序:属于”分配式排序”(distribution sort)基数排序法又称“桶子法”(bucket sort)或bin sort。 链式基数排序思想:透过键值的部份资讯,将要排序的元素分配至某些“桶”中,藉以达到排序的作用,基数排序法是属于稳定性的排序,其时间复杂度为O (nlog(r)m),其中r为所采取的基数,而m为堆数。 时间效率:设待排序列为n个记录,d个关键码,关键码的取值范围为radix,则进行链式基数排序的时间复杂度为O(d(n+radix)),其中,一趟分配时间复杂度为O

保福寺计算机 的专栏 2579

博途 V16(TIA portal V16)安装教程

本文提供了西门子TIA Portal V16软件的完整安装指南。内容包括百度网盘下载链接(提取码kv69)、详细安装步骤(关闭安全保护、典型安装设置)、授权破解方法,以及PLCSIM仿真功能的使用说明。重点演示了S7-1200 PLC程序的仿真过程,解析了仿真界面各元素功能,包括状态指示灯(RUN/STOP/ERROR)、操作按钮(RUN/STOP/MRES)和网络接口状态等。通过图文并茂的方式,完整呈现了从软件安装到PLC程序仿真的全流程操作。

lingchen1906的博客 6818

基数排序——详解

基数排序(英语:Radix sort)是一种非比较型的排序算法,最早用于解决卡片排序的问题。基数排序将待排序的元素拆分为个关键字,逐一对各个关键字排序后完成对所有元素的排序。如果是从第关键字到第关键字顺序进行比较,则该基数排序称为 MSD(Most Significant Digit first)基数排序;如果是从第关键字到第关键字顺序进行比较,则该基数排序称为 LSD(Least Significant Digit first)基数排序。

w_w_wwwww的博客 1241

[QMT量化交易小白入门]-四、如何筛选优质可转债,并进行下单操作

通过上述步骤,成功地使用Python代码完成了可转债的筛选、数据处理和下单操作。当然,这只是一个基础的示例,实际投资中还需要考虑更多因素,如市场环境、资金管理、风险控制等。希望本文能为各位投资者提供一些有价值的参考,助力大家在投资道路上走得更远。

木头大左的博客 1734

OpenOCD入门到精通:第 4 章 配置文件体系详解

本文深入解析OpenOCD配置文件的体系结构和工作机制。首先介绍了配置文件的搜索路径优先级和加载顺序,以及配置阶段与运行阶段的区别。然后详细分析了interface配置文件的适配器参数调优方法,包括ST-Link、CMSIS-DAP和FTDI等常见调试器的配置示例。最后重点讲解了target配置文件的核心结构,包括TAP声明、目标创建和工作区设置等关键步骤,并以stm32f1x为例展示了完整的配置流程。通过本文可以全面了解OpenOCD配置文件的分层设计理念和参数化配置方法。

从事嵌入式linux android驱动开发,拥有全栈能力 598

基数排序算法

文章目录一、基数排序概述二、基数排序的步骤三、基数排序的代码实现 一、基数排序概述 基数排序(radix sort)属于 “分配式排序”(distribution sort),又称 “桶子法”(bucket sort)。基数排序的基本思想是:通过待排序元素的各个位的值,将待排序元素分配至某些 “桶” 中,达到排序的效果。 基数排序是桶排序的扩展,基数排序法是效率高的稳定性排序法。 二、基数排序的步骤 基数排序过程一般遵循下面的基本步骤: 首先确定待排序序列 arr 中最大的元素,得出元素的位数 N,位

Ronz 的博客 2703

Oracle EBS与SAP数据数据切换至迁移华为MetaERP分析

Oracle EBS到华为MetaERP的数据迁移可采用“表对表复制”思路,因其模块化设计下数据模型标准化、边界清晰。核心业务对象存储在结构明确的主表中,与MetaERP模型兼容度高,便于直接映射。而SAP到MetaERP的迁移则因SAP高度优化的复杂表结构(如簇表/池表)、数据分散冗余、深度依赖配置等特点,无法简单复制,必须采用基于业务对象的迁移方法,通过视图/BAPI提取数据并进行深度转换。两种迁移的本质差异源于源系统的数据模型设计理念不同。

金牌架构师 1379

基数排序详解

基本概念: 基数排序(英语:Radix sort)是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数。 它是这样实现的:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到

daiyudong2020的博客 5221

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

C++ 基数排序

基数排序的原理: (1)首先,把整数通过求余的方式拆分成“个位、十位、百位、… ”; (2)然后,统计每个整数的“个位、十位、百位、… ”出现的次数,之后把次数存到以“余数”为编号的桶子里; (3)最后,通过一个整数出现的次数-1,从而算出正确顺序的位置,再把整数放进去,就有顺序了。 #include &lt;iostream&gt; #include &lt;stdlib.h&gt; ...

辛旭东小小工作室 824

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

【算法】基数排序

计数排序 学习基数排序之前首先学习计数排序。 计数排序假设每个元素都是在0到k之间的一个整数。 基数排序的基本思想,对于每个元素x,如果我们知道了小于x的元素的个数,就可以确定输出数组中元素x的位置,那么直接将元素x放到输出数组中。比如有3小于x的元素,那在输出数组中,x肯定位于第4个位置。 计数排序的算法用伪代码描述为: COUNTING-SORT(A,k) // 初始化数组C

weiersyuan的专栏 4416

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

基数排序原理

算法和数据结构

实践求真知 624

基数排序·静态-链式

基数排序静态基数排序实现过程代码分析链式基数排序实现过程代码分析 静态基数排序 当m很大时,可以将一个记录的值即排序码拆分为多个部分来进行比较 例如:对0到9999之间的整数进行排序 1.将四位数看作是由四个排序码决定,即千,百,十,个位,其中千位为最高排序码,个位为最低排序码。基数r=10 2.可以按千百十个位数字依次进行4次桶式排序 3.4趟分配排序后,整个序列就排好序了 高位优先法: 先处理高位k d-1将序列分到若干桶中 然后再对每个桶处理次高位k d-2,分成更小的桶 依次重复,直到对k0排序后,

zhj12399的博客 1046
上一篇: 归并排序
下一篇: 各种内部排序算法复杂度的比较和排序方法的选择
早起的虫儿灬
博客等级 码龄10年 54粉丝 114原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值