第二个例子：单链表实现基排序（桶排序）

最新推荐文章于 2024-05-31 09:44:20 发布
最新推荐文章于 2024-05-31 09:44:20 发布
阅读量96 收藏
点赞数
文章标签： 数据结构与算法 python
原文链接：https://my.oschina.net/u/3397950/blog/872539
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

//单链表基排序（桶排序） 
//main.c
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include "List.h"
#include<stdbool.h>

void Create_barrel(List *L);
void input_barrel(List *L,int val);
int output_barrel(List *L);

int main(void)
{
	int data[]={64,8,216,512,27,729,0,1,343,125}; 
	int JPX_num=0;    //基排序进行次数              
	int j;
	int i;
	int WEI;    //个十百位 
	int LEN;        // 数组大小 
	int k;
	int Yushu;     //余数 
	int power=1;   //10的倍数 
	LEN=sizeof(data)/(sizeof(int));       //数组中数据个数 
	bool Jiaoyan=1;      //最大的位数 
	List barrel_num[10];     //0-10的桶 
	           
	while(Jiaoyan)
	{
		Jiaoyan=0; 
		for(j=0;j<LEN;j++)
		{
			WEI=(data[j]/power)%10;
			Jiaoyan=Jiaoyan||WEI;                     //获取数组里元素的最高位数 
		}
		power*=10;
		JPX_num++;
	}
	JPX_num-=1;
	 
	for(j=0;j<10;j++)
	{
		Create_barrel(&barrel_num[j]);                 //为每个桶生成空链表，用于存储之后数据 
	}
	//排序
	power=1;
	for(j=0;j<JPX_num;j++)
	{
		for(i=0;i<LEN;i++)
		{
			Yushu=(data[i]/power)%10;
			input_barrel(&barrel_num[Yushu],data[i]);            //把数依次入桶 
		}
		k=0;
		for(i=0;i<10;i++)
		{
			while(!IsEmpty(barrel_num[i]))
			{
				data[k]=output_barrel(&barrel_num[i]);          //入完桶后依次出桶，已准备下一次如同排序 
				k++;
			}
		}
		power*=10;
	} 
	
	for(i=0;i<LEN;i++)
	{
		printf("%d ",data[i]);                      //打印排序后的数组 
	}
}

void Create_barrel(List *L)
{
	*L=(List)malloc(sizeof(struct Node));      //创建0-9共10个桶 
	(*L)->Next=NULL;
}

void input_barrel(List *L,int val)
{
	InsertH(val,*L,*L);                    //入桶（相当于单链表的后插） 
} 
int output_barrel(List *L)
{
	List m;
	m=(*L)->Next;
	int a=m->Element;                      //出桶（相当于单链表从第一个元素依次删除） 
	(*L)->Next=(*L)->Next->Next;
	free(m);
	return a;
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//List.h
#ifndef _LIST_H_
typedef int ElementType;

struct Node;

typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

struct Node
{
	ElementType Element;
	Position Next;
};

void CreateList(List *L,int n);
void PrintList(List L);

List MakeEmpty(List L);
int IsEmpty(List L);
void CreateEmptyList(List *L);
int IsLast(Position P,List L);
Position Find(ElementType X,List L);
void Delete(ElementType X,List L);
Position FindPrevious(ElementType X,List L);
void Insert(ElementType X,List L,Position P);
void InsertH(ElementType X,List L,Position P);
void DeleteList(List L);
Position Header(List L);
Position First(List L);
Position Advance(Position P);
ElementType Retrieve(Position P);

#endif
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//List.c
#include "List.h"
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

/*struct Node
{
	ElementType Element;
	Position Next;
};*/

void CreateList(List *L,int n)
{
	Position P,P1;
	int i;
	*L=(Position)malloc(sizeof(struct Node));
	(*L)->Next=NULL;
	P1=*L;
	printf("请输入%d个数据：\n",n);                    //没问题 
	for(i=n;i>0;i--)
	{
		//P=(Position)malloc(sizeof(struct Node));
	    //scanf("%d",&P->Element);                //前插 
	    //P->Next=(*L)->Next;
	    //(*L)->Next=P;
		
		P=(Position)malloc(sizeof(struct Node));
		scanf("%d",&P->Element);
		P->Next=P1->Next;                       //后插 
		P1->Next=P;
		P1=P;
	
	}
}

void PrintList(List L)
{
	printf("已保存链表\n");
	Position P;
	P=L->Next;
	while(P->Next!=NULL)
	{
		printf("%d ",P->Element);              //没问题 
		P=P->Next;
	}
	printf("%d ",P->Element);
}

void FatalError(char a[])
{
	printf("%s",a);                           //没问题 
}

int IsEmpty(List L)
{
	return L->Next==NULL;                     //没问题 
}

int IsLast(Position P,List L)
{
	return P->Next==NULL; 
}

List MakeEmpty(List L)
{
	List q,p;
	p=L->Next;
	while(p!=NULL)
	{                                            //没问题 
		q=p->Next;
		free(p);
		p=q;
		
	}
	L->Next=NULL;
	
	return L;
}

Position Find(ElementType X,List L)
{
	Position P;
	P=L->Next;
	while((P->Next!=NULL)&&(P->Element!=X))        //没问题 
	{
		P=P->Next;
	}
	
	return P;
}

Position findPrevious(ElementType X,List L)
{
	Position P;
	P=L;
	while((P->Next!=NULL)&&(P->Next->Element!=X))    //没问题 
	{
		P=P->Next;
	}
	
	return P;
}

void Delete(ElementType X,List L)
{
	Position P,TmpCell;
	P=findPrevious(X,L);
	if(!IsLast(P,L))
	{
		TmpCell=P->Next;
		P->Next=TmpCell->Next;                   //没问题 
		free(TmpCell);
	}
}
void DeleteList(List L)
{
	Position P,Q;
	P=L->Next;
	L->Next=NULL;
	while(P!=NULL)
	{
		Q=P->Next;                               //没问题 
		free(P);
		P=Q;
	}
}
void Insert(ElementType X,List L,Position P)
{
	if(L==NULL)
	{
		return;
	} 
	Position TmpCell;
	TmpCell=malloc(sizeof(struct Node));
	if(TmpCell!=NULL)
	{
		TmpCell->Next=P->Next;                   //前插，没问题 
		TmpCell->Element=X;
		P->Next=TmpCell;
	}
	else
	{
		FatalError("out of space!!!");
	} 
}
void InsertH(ElementType X,List L,Position P)
{
	if(L==NULL)
	{
		return;
	} 
	Position TmpCell;
	List q;
	TmpCell=malloc(sizeof(struct Node));
	q=L;                                            //后插，没问题 
	while(q->Next!=NULL)
	{
		q=q->Next;
	}
	q->Next=TmpCell;
	TmpCell->Next=NULL;
	TmpCell->Element=X;
}
void CreateEmptyList(List *L)
{
	*L=(Position)malloc(sizeof(struct Node));
	(*L)->Next=NULL;
}

//List.h
#ifndef _LIST_H_
typedef int ElementType;

struct Node;

typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

struct Node
{
    ElementType Element;
    Position Next;
};

void CreateList(List *L,int n);
void PrintList(List L);

List MakeEmpty(List L);
int IsEmpty(List L);
void CreateEmptyList(List *L);
int IsLast(Position P,List L);
Position Find(ElementType X,List L);
void Delete(ElementType X,List L);
Position FindPrevious(ElementType X,List L);
void Insert(ElementType X,List L,Position P);
void InsertH(ElementType X,List L,Position P);
void DeleteList(List L);
Position Header(List L);
Position First(List L);
Position Advance(Position P);
ElementType Retrieve(Position P);

#endif


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

//List.c
#include "List.h"
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

/*struct Node
{
    ElementType Element;
    Position Next;
};*/

void CreateList(List *L,int n)
{
    Position P,P1;
    int i;
    *L=(Position)malloc(sizeof(struct Node));
    (*L)->Next=NULL;
    P1=*L;
    printf("请输入%d个数据：\n",n);                    //没问题 
    for(i=n;i>0;i--)
    {
        //P=(Position)malloc(sizeof(struct Node));
        //scanf("%d",&P->Element);                //前插 
        //P->Next=(*L)->Next;
        //(*L)->Next=P;
        
        P=(Position)malloc(sizeof(struct Node));
        scanf("%d",&P->Element);
        P->Next=P1->Next;                       //后插 
        P1->Next=P;
        P1=P;
    
    }
}

void PrintList(List L)
{
    printf("已保存链表\n");
    Position P;
    P=L->Next;
    while(P->Next!=NULL)
    {
        printf("%d ",P->Element);              //没问题 
        P=P->Next;
    }
    printf("%d ",P->Element);
}

void FatalError(char a[])
{
    printf("%s",a);                           //没问题 
}

int IsEmpty(List L)
{
    return L->Next==NULL;                     //没问题 
}

int IsLast(Position P,List L)
{
    return P->Next==NULL; 
}

List MakeEmpty(List L)
{
    List q,p;
    p=L->Next;
    while(p!=NULL)
    {                                            //没问题 
        q=p->Next;
        free(p);
        p=q;
        
    }
    L->Next=NULL;
    
    return L;
}

Position Find(ElementType X,List L)
{
    Position P;
    P=L->Next;
    while((P->Next!=NULL)&&(P->Element!=X))        //没问题 
    {
        P=P->Next;
    }
    
    return P;
}

Position findPrevious(ElementType X,List L)
{
    Position P;
    P=L;
    while((P->Next!=NULL)&&(P->Next->Element!=X))    //没问题 
    {
        P=P->Next;
    }
    
    return P;
}

void Delete(ElementType X,List L)
{
    Position P,TmpCell;
    P=findPrevious(X,L);
    if(!IsLast(P,L))
    {
        TmpCell=P->Next;
        P->Next=TmpCell->Next;                   //没问题 
        free(TmpCell);
    }
}
void DeleteList(List L)
{
    Position P,Q;
    P=L->Next;
    L->Next=NULL;
    while(P!=NULL)
    {
        Q=P->Next;                               //没问题 
        free(P);
        P=Q;
    }
}
void Insert(ElementType X,List L,Position P)
{
    if(L==NULL)
    {
        return;
    } 
    Position TmpCell;
    TmpCell=malloc(sizeof(struct Node));
    if(TmpCell!=NULL)
    {
        TmpCell->Next=P->Next;                   //前插，没问题 
        TmpCell->Element=X;
        P->Next=TmpCell;
    }
    else
    {
        FatalError("out of space!!!");
    } 
}
void InsertH(ElementType X,List L,Position P)
{
    if(L==NULL)
    {
        return;
    } 
    Position TmpCell;
    List q;
    TmpCell=malloc(sizeof(struct Node));
    q=L;                                            //后插，没问题 
    while(q->Next!=NULL)
    {
        q=q->Next;
    }
    q->Next=TmpCell;
    TmpCell->Next=NULL;
    TmpCell->Element=X;
}
void CreateEmptyList(List *L)
{
    *L=(Position)malloc(sizeof(struct Node));
    (*L)->Next=NULL;
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

//单链表基排序（桶排序） 
//main.c
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include "List.h"
#include<stdbool.h>

void Create_barrel(List *L);
void input_barrel(List *L,int val);
int output_barrel(List *L);

int main(void)
{
    int data[]={64,8,216,512,27,729,0,1,343,125}; 
    int JPX_num=0;    //基排序进行次数              
    int j;
    int i;
    int WEI;    //个十百位 
    int LEN;        // 数组大小 
    int k;
    int Yushu;     //余数 
    int power=1;   //10的倍数 
    LEN=sizeof(data)/(sizeof(int));       //数组中数据个数 
    bool Jiaoyan=1;      //最大的位数 
    List barrel_num[10];     //0-10的桶 
               
    while(Jiaoyan)
    {
        Jiaoyan=0; 
        for(j=0;j<LEN;j++)
        {
            WEI=(data[j]/power)%10;
            Jiaoyan=Jiaoyan||WEI;                     //获取数组里元素的最高位数 
        }
        power*=10;
        JPX_num++;
    }
    JPX_num-=1;
     
    for(j=0;j<10;j++)
    {
        Create_barrel(&barrel_num[j]);                 //为每个桶生成空链表，用于存储之后数据 
    }
    //排序
    power=1;
    for(j=0;j<JPX_num;j++)
    {
        for(i=0;i<LEN;i++)
        {
            Yushu=(data[i]/power)%10;
            input_barrel(&barrel_num[Yushu],data[i]);            //把数依次入桶 
        }
        k=0;
        for(i=0;i<10;i++)
        {
            while(!IsEmpty(barrel_num[i]))
            {
                data[k]=output_barrel(&barrel_num[i]);          //入完桶后依次出桶，已准备下一次如同排序 
                k++;
            }
        }
        power*=10;
    } 
    
    for(i=0;i<LEN;i++)
    {
        printf("%d ",data[i]);                      //打印排序后的数组 
    }
}

void Create_barrel(List *L)
{
    *L=(List)malloc(sizeof(struct Node));      //创建0-9共10个桶 
    (*L)->Next=NULL;
}

void input_barrel(List *L,int val)
{
    InsertH(val,*L,*L);                    //入桶（相当于单链表的后插） 
} 
int output_barrel(List *L)
{
    List m;
    m=(*L)->Next;
    int a=m->Element;                      //出桶（相当于单链表从第一个元素依次删除） 
    (*L)->Next=(*L)->Next->Next;
    free(m);
    return a;
}
 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

输入数组：int data[]={64,8,216,512,27,729,0,1,343,125}; 

排序结果：0 1 8 27 64 125 216 343 512 729
--------------------------------
Process exited after 0.03693 seconds with return value 10
请按任意键继续. . .

转载于:https://my.oschina.net/u/3397950/blog/872539

weixin_33766805
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python实现桶排序.rar
09-22
Python实现桶排序.rar
基数排序单链表实现(C语言)
Shayabean->MyBlog
04-05 3929
头文件： /*基数排序，单链表实现*/ #ifndef RADIX_SORT_H #define RADIX_SORT_H #include #define FLOWOVER -1 #define LIST_EMPTY -2 struct RadixSort; typedef struct RadixSort * List; typedef struct RadixSort * Node;
链表面试题-单链表排序(冒泡，快速，归并)
Maple的博客
03-15 2839
面试中单链表是一个被问及频率很高的问题，这几天同学面试中多次被问及，所以今天整理一下。 注：对链表排序时，只需要交换结点间的_data即可，如果想法是改变指针，那么只能是走弯路了。 结点类型 struct Node { //构造函数 Node(int data) :_next(nullptr) ,_data(data) {} Node...
单向链表之排序（C语言实现）
热门推荐
peng_fp的博客
03-20 1万+
链表的创建查看 链表的排序有三种情况： 1、链表为空时：不用排序； 2、链表中有一个节点：不用排序； 3、链表中两个及其以上节点时：排序。 结构体节点： typedef struct student { int num; //学号 int score; //分数 char name[20]; struct student
单链表实现基数排序
polyhedronx的博客
08-07 1929
《数据结构与算法分析》练习题系列。 书上第3章在讲解链表时举了一个基数排序的例子，给出了具体的思路，但没有给出程序，而且我大致搜了一下，发现大部分人都是用数组写的，所以我想试着用单链表实现。 关于什么是基数排序，这个书上有很详细的讲解，这里不再赘述。单链表结构：struct Node; typedef struct Node *PtrToNode; typedef PtrToNode List;
C++实现桶排序（源代码）
05-07
桶排序是一种基于分治策略的排序算法，它通过将待排序的数据分配到...在C++实现中，可以通过根据数据范围和数组大小来设定桶的大小，并使用标准库中的排序函数对每个桶进行排序，最后再将排序后的数据合并回原数组。
Java实现桶排序算法（源代码）
05-07
桶排序是一种基于分治策略的排序算法，它通过将待排序的数据分配到...在Java实现中，可以通过根据数据范围和数组大小来设定桶的大小，并使用标准库中的排序函数对每个桶进行排序，最后再将排序后的数据合并回原数组。
Python3实现桶排序（源代码）
05-06
桶排序是一种基于数据分布的排序算法，它通过将数据分配到有限数量的桶中，然后对每个桶中的数据进行排序，最后合并桶中的数据来实现对整个数据的排序。桶排序适用于数据分布均匀的情况，其时间复杂度可以达到线性...
JS桶排序的简单理解与实现方法示例
10-15
主要介绍了JS桶排序的简单理解与实现方法,结合实例形式详细分析了js桶排序的概念、原理、实现方法及操作注意事项,需要的朋友可以参考下
基于单链表实现的桶排序
caiji
03-03 408
桶排序 1.问题描述：使用桶排序算法对控制台输入的数字进行排序 2. 桶排序涉及到几个问题： 1.桶的大小，这里我们可以根据输入的元素的个数来确定桶的大小 2.怎么确定当前元素进入哪一个桶，这里我们使用到的是通过一个哈希函数来进行计算 int index = (element * length) / (max + 1); element为当前元素的值，length为桶的大小，max为...
基数排序/桶排序-单链表实现
dingwei0552的博客
09-02 162
今天下午编程实现了基数排序（桶排序），只能说一千个人有一千个哈姆雷特，因此，一千个人可能有一千种基数排序的实现方式，无论是用数组，栈，队列，单链表（都是线性表哦， 好巧，哈哈）。重要的是理解该排序算法的思路后，自己也就可以尝试着慢慢写出来了。时间关系，暂且只给出跟人代码（面试黄金月），以后有机会再补充实现思路。新手出道，代码可读性不要期望太高，多包涵，相信以后自己会进步的。 t...
单链表排序
JianWu0121的博客
02-10 1958
单链表（Linked List）是编程问题中的常见问题，单链表的排序关键在交换，交换有两种方式 一种是节点值的交换，另一种是节点的交换。以下给出三种常见的排序算法。 归并排序 class Solution { public: ListNode* merge(ListNode* l1, ListNode* l2) { ListNode* dummy = new Li...
桶排序的单链表实现及其变种
极客学长 | 极客学长Bravo
05-01 1719
《算法导论》中桶排序问题的单链表实现 《算法导论》CLRS 第八章 线性时间排序 8.4 桶排序 桶排序的思想就是把区间[0, 1)划分成n个相同大小的子区间，每一个区间称为桶（bucket）。然后，将n个输入数据分布到各个桶中去。因为输入数均匀且独立均匀分布在[0, 1)上，所以一般不会有很多数落在一个桶中的情况。为得到结果，先对各个桶中的数
单链表版桶排序
bytedance的博客
05-24 198
public class BucketSort implements AscSortInterface { @Override public int[] sortAsc(int[] arr) { if (null == arr || arr.length <= 1){ return arr; } // how many buckets int minVal = Arrays.stream(ar.
单链表快速排序算法的实现
runner668的博客
04-02 1万+
快速排序： 　　 快速排序的主要思想是： 　　 1）选定一个基准元素 　　 2）经过一趟排序，将所有元素分成两部分 　　 3）分别对两部分重复上述操作，直到所有元素都已排序成功 　　 因为单链表只能从链表头节点向后遍历，没有prev指针，因此必须选择头节点作为基准元素。这样第二步操作的时间复杂度就为O(n)。由于之后都是分别对两部分完成上述操作，因此会将链表划分为lgn个段，因此时间复杂度为O(n...
159.二叉树：二叉树的层平均值（力扣）
最新发布
weixin_63779802的博客
05-31 326
代码同样使用了广度优先搜索（BFS）的方法。主要思路是使用一个队列来进行层次遍历，在每一层遍历的时候，计算所有节点的值的总和以及节点的数量，然后用总和除以节点数量得到平均值。这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储整个树的节点。代码是解决“二叉树的层平均值”问题的C++代码，这个问题要求计算二叉树中每一层的节点值的平均值，并返回一个包含这些平均值的列表。
用python代码分别实现计数排序、基排序和桶排序算法
05-05
基排序： ```python def radix_sort(arr): max_num = max(arr) exp = 1 while max_num // exp > 0: buckets = [[] for _ in range(10)] for num in arr: buckets[(num // exp) % 10].append(num) arr = [] ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值