# C language cardinality sort -- the realization of sequence queue

### Basic requirements:

Input n integers of m degree from the keyboard, and output the ascending arrangement of these integers.

### Specific requirements:

1. The data structure used is queue, which is realized by sequence queue
2. Good human-computer interaction
3. Be able to output the distribution and collection of each trip

### Basic concepts:

Cardinality sorting belongs to distributive sorting, also known as bucket method. Through the query of key value, the elements to be sorted are assigned to some "buckets" to achieve the purpose of sorting.

### Specific ideas:

Take reshaping as an example, divide the reshaping decimal by each bit, and then compare from low to high

It is mainly divided into two processes:

For allocation, start from bits, and put them into buckets 0-9 according to bit value (0-9)

Collect, and then put the data placed in buckets 0-9 into the array in order

Repeat the allocation and collection process. The number of repeats is from bit to the highest bit

### Code implementation:

```#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef int QElemType;
typedef struct
{
QElemType *base;       //Initial dynamic allocation of space, storage of data
int front;              //Head pointer, pointing to the queue head element, used to move
int rear;               //Tail pointer, pointing to the next position of the queue tail element, to determine the length
} SqQueue;

//distribute for n th distribution
//The original data is stored in the Q.base array
//ArrType is an array of type SqQueue,
void distribute(SqQueue &Q,int n,SqQueue ArrType[])
{
//quot- quotient
//rem - stores the value of the nth bit (i.e. the first, second, and Nth bit) of each data
int i,c,temp,quot,rem;
ArrType[i].front=0;
//for processes the n th bit of each data
for(i=0; i<Q.rear; i++)
{
//Stage i data to quot e
quot=Q.base[i];
c=0;
//while calculates the value of the nth bit of the ith data and saves it to rem
while(c<n)
{
c++;
}
//Copy the data whose n th bit is rem to the remth queue
//That is, according to the nth digit rem of data, data is allocated to the end of the remth queue
ArrType[rem].base[ArrType[rem].front++]=Q.base[i];
}
printf("The first%d After a trip assignment:\n",n);
{
temp=ArrType[i].front;
//if the i-th queue is not empty
if(temp>0)
{
for(c=0; c<temp-1; c++)
printf("%d-",ArrType[i].base[c]);
printf("%d<-queue[%d]Tail pointer rear\n",ArrType[i].base[temp-1],i);
}
}
}

//collect for the n th collection
//ArrType saves the results of the n-1 assignment
void collect(SqQueue &Q,int n,SqQueue ArrType[])
{
//Collected records the amount of data collected
int i,collected=0;

//for collects data from array ArrType into int array Q.base
{
//if the i-th queue is not empty, collect its data
if(ArrType[i].front!=0)
{
//Collect (simply copy to Q.base array)
memcpy(Q.base+collected,ArrType[i].base,ArrType[i].front*sizeof(int));
collected+=ArrType[i].front;
}
}
printf("The first%d After the collection:\n",n);
for(i=0; i<=Q.front-1; i++)
{
printf("%d ",Q.base[i]);
}
printf("\n\n");
}

//Calculate the initial length of each queue (1 / radius of the amount of data)
void Ord(SqQueue &Q,SqQueue ArrType[],int M)
{
int i;
int temp=M;

{
//Allocate space for the i th queue
ArrType[i].base=(int*)calloc(temp,sizeof(int));
ArrType[i].rear=temp;
}
}

//for M (M is the length of each data input) times allocation and collection
{
for(int i=1; i<=M; i++)
{
distribute(Q,i,ArrType);
collect(Q,i,ArrType);
}
}

int main()
{
int i,M;
printf("Please enter the length of each data:");
scanf("%d",&M);
printf("Please enter the total number of data:");
scanf("%d",&Q.rear);
Q.base=(int*)calloc(Q.rear,sizeof(int));
Q.front=0;
printf("Please input%d The length is%d Data:\n",Q.rear,M);
for(i=0; i<Q.rear; i++)
scanf("%d",&Q.base[Q.front++]);
printf("\n");
Ord(Q,ArrType,M);
//The following free releases dynamically allocated memory
free(Q.base);
free(ArrType[i].base);
system("PAUSE");
return 0;
}```

### Last word:

The cardinality sort method is a stable sort, whose time complexity is O (nlog(r)m), where r is the cardinality and M is the heap number

In some cases, the efficiency of Radix sorting is higher than that of other stable sorting methods.

Posted on Fri, 31 Jan 2020 21:14:05 -0500 by rayfinkel2