基数排序

代码基本基于大神，自己研究精进了一下

/*typedef struct {
	int Coefficient;//系数  
	int Exponent;//指数  
}ElementType;//针对多项式的结构声明，不知道是否可以调换，MARK并尝试；事实上必须声明*/
typedef int ElementType;

#ifndef _List_H    
#define _List_H    

struct Node;//要在之后的cpp中定义

typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;
/*struct Node
{
	ElementType Element;
	Position Next;
};//把node定义出来*/

List CreatList();//创建列表
List MakeEmpty(List L);//清空列表
int IsEmpty(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 DeleteList(List L);//删除
Position Header(List L);//开头
Position First(List L);//第一个
Position Advance(Position P);//前面一项
ElementType Retrieve(Position P);//重现实体
void deleteNext(Position p);//删除下一项
void InsertFront(ElementType e, List L);
void InsertBack(ElementType e,List L);
#endif  

#include<stdlib.h>
#include"listown.h" 
struct Node
{
	ElementType Element;
	Position Next;
};//把node定义出来

//因为struct涉及到两个量，所以我们设计一个cmp
/*int elementcmp(ElementType e1,ElementType e2)
{
	return
		e1.Coefficient == e2.Coefficient
		&&
		e1.Exponent == e2.Exponent;
}*/
List CreatList()
{
	List list = (Position)malloc(sizeof(struct Node));//申请内存，注意进行强制类型转换
	if (list == NULL)
	{
		perror("out of memory");//报错检验
	}
	list->Next = NULL;
	return list;
};//创建列表
List MakeEmpty(List L)
{
	if (L != NULL) {
		DeleteList(L);
		L->Next = NULL;
		return L;
	}
	else {
		L = (List)malloc(sizeof(struct Node));
		if (L == NULL)
			perror("Out of memory");
		L->Next = NULL;
		return L;
	}
};//清空列表
int IsEmpty(List L)
{
	return L->Next == NULL;
};//判断列表是否为空
int IsLast(Position P, List L)
{
	return P->Next == NULL;
};//判断是否为末尾
/*Position Find(ElementType X, List L)
{
	Position P;
	P = FindPrevious(X,L);
	while (P!=NULL && elementcmp(P->Element,X))
	{
		P = P->Next;
	}
	return P;
};//寻找函数*/
/*void Delete(ElementType X, List L)
{
	Position P;
	P = FindPrevious(X, L);
	if (!IsLast(P,L))
	{
		Position temp = P->Next;
		P->Next = temp->Next;
		free(temp);
	}
};*///删除函数
/*Position FindPrevious(ElementType X, List L)
{
	Position P;
	P = L;
	while (P->Next != NULL && elementcmp(P->Next->Element, X))
	{
		P = P->Next;
	}
	return P;
};//删除某项的前一项*/
void Insert(ElementType X,List L,Position P)
{
	Position temp;
	temp = (List)malloc(sizeof(struct Node));
	if (temp == NULL)perror("out of space");
	temp->Element = X;
	temp->Next = P->Next;
	P->Next = temp;
};//插入
void DeleteList(List L)
{
	Position P;
	P = L->Next;
	L->Next = NULL;
	while (P!=NULL)
	{
		Position temp;
		temp = P->Next;
		free(P);
		P = temp;
	}
	
};//删除
Position Header(List L)
{
	return L;
};//开头
Position First(List L)
{
	return L->Next;
};//第一个
Position Advance(Position P)
{
	return P->Next;
};//后面一项
ElementType Retrieve(Position P)
{
	if (P == NULL) { perror("List is not exist");	return 0; }
	return P->Element;
};//重现实体
void deleteNext(Position P)
{
	Position temp;
	temp = P->Next;
	P->Next = temp->Next;
	free(temp);
};//删除下一项
void InsertFront(ElementType e, List L)
{
	Insert(e,L, L);
};
void  InsertBack(ElementType X, List L) {
	Position last;
	last = L;
	while (last->Next != NULL)
		last = last->Next;
	Insert(X,L,last);
}

#include"listown.h"
#include<stdio.h>
#include<stdlib.h>
#define Buckets 10 //桶的数量
#define N 10  //排序数量
#define bits 3 //位数
int AU[N];
void printarray(int ARRI[], int len)
{
	for (int i = 0; i<len; i++)
	{
		printf("%d,", ARRI[i]);
	}
	printf(";\n");
}//输出数组
int getDigital(int x, int cnt)
{
	for (int i = 0; i < cnt; i++)
	{
		x /= 10;
	}
	return x % 10;
}//获取所谓基数//截位

void radixSort(int arr[])
{
	List bucket[Buckets];//链表可以用于数列，链表列
	int i, j, k;
	for ( i = 0; i < Buckets; i++)
	{
		bucket[i] = MakeEmpty(NULL);
		//初始化，相当于//其实这里的makeempty兼顾了初始化和清空//所以前面的函数得修改
		//printf("test");
	}
	for (i = 0;i < bits;i++)
	{
		for (j = 0; j<Buckets;j++)
		{
			MakeEmpty(bucket[j]);
			//printf("test   %d",j);
		}
		for (k = 0; k < N; k++)
		{
			InsertBack(arr[k], bucket[getDigital(arr[k], i)]);//算法核心，层层桶式
			//printf("test %d\n", Retrieve(bucket[getDigital(arr[k], i)]->Next));

		}
		//printf("test %d\n", Retrieve(bucket[5]->Next->Next));
		for (int l = 0,m=0; l < N; l++)
		{
			Position P;
			P = First(bucket[l]);//这里未调整指针指向，导致P指向未知，程序无法继续
			//printf("test %d", Retrieve(P));
			while (P != NULL)
			{
				arr[m++] = Retrieve(P);
				//printf("test2 %d", Retrieve(P));
				P = Advance(P);
			}
		}
	   }
	for (i = 0; i < Buckets; i++)
	{
		DeleteList(bucket[i]);//释放空间
	}


}
int input()
{
	char ch = 'S';
	int N1, count = 0;
	printf("输入你想要的序列\n（输入字母·表示退出）请输入第1个数：");
	while (1)
	{
		while (scanf_s("%d", &N1) == 1)
		{
			AU[count] = N1;
			count++;
			printf("请输入第%d个数：",count+1);
		}
		while (getchar() != '\n');//字母还留在输入流当中，scanf是不会删去的 
		return count;
	}
}
 void main()
 { 
	 printf("您输入了%d个数", input());
	 //int BU[10] = { 64, 8, 216, 987, 27, 729, 0, 1, 343, 125 };
	 printarray(AU, N);
	 radixSort(AU);
	 printarray(AU, N);
	 system("pause");
 }