c语言体重排序_十大排序C语言实现

#include

#include

void bubbleSort(int arr[],int size);

void SelectionSort(int *arr, int size);

void InsertionSort(int *arr, int size);

void ShellSort(int *arr, int size);

void Merge(int *SR, int *TR, int i, int middle, int rightend);

void MergeSort(int *SR, int *TR1, int s, int t);

void swap(int *a, int *b) ;

void QuickSort(int *arr, int maxlen, int begin, int end);

void HeapSort(int *arr, int size);

void CountSort(int *arr,int n);

void bucketSort(int *arr, int size);

void RadixSort(int *arr, int len, int dec, int order);

int main()

{

int arr[10] = {1,9,6,3,5,2,4,8,7,10},i=0;

//BubbleSort(arr,10);

//SelectionSort(arr,10);

//InsertionSort(arr,10);

//ShellSort(arr,10);

//int arr_merge[10]={0};

//MergeSort(arr,arr_merge,0,9);

//QuickSort(arr,10,0,9);

//HeapSort(arr,9);

//CountSort(arr,10);

//bucketSort(arr,10);

RadixSort(arr,10,2,1);

for(i=0;i<10;i++)

{

printf("arr[%d] = %d\n",i,arr[i]);

}

printf("\n");

return 0;

}

/*冒泡排序*/

void BubbleSort(int arr[], int size)

{

int i, j, tmp;

for (i = 0; i < size - 1; i++) {

for (j = 0; j < size - i - 1; j++) {

if (arr[j] > arr[j+1]) {

tmp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = tmp;

}

}

}

}

/*选择排序*/

void SelectionSort(int *arr, int size)

{

int i, j, k, tmp;

for (i = 0; i < size - 1; i++) {

k = i;

for (j = i + 1; j < size; j++) {

if (arr[j] < arr[k]) {

k = j;

}

}

tmp = arr[k];

arr[k] = arr[i];

arr[i] = tmp;

}

}

/*插入排序*/

void InsertionSort(int *arr, int size)

{

int i, j, tmp;

for (i = 1; i < size; i++) {

if (arr[i] < arr[i-1]) {

tmp = arr[i];

for (j = i - 1; j >= 0 && arr[j] > tmp; j--) {

arr[j+1] = arr[j];

}

arr[j+1] = tmp;

}

}

}

/*希尔排序*/

void ShellSort(int *arr, int size)

{

int i, j, tmp, increment;

for (increment = size/ 2; increment > 0; increment /= 2) {

for (i = increment; i < size; i++) {

tmp = arr[i];

for (j = i - increment; j >= 0 && tmp < arr[j]; j -= increment) {

arr[j + increment] = arr[j];

}

arr[j + increment] = tmp;

}

}

}

/*归并排序*/

void Merge(int source[],int temp[], int start, int mid, int end)

{

int i = start, j=mid+1, k = start;

while(i!=mid+1 && j!=end+1)

{

if(source[i] > source[j])

temp[k++] = source[j++];

else

temp[k++] = source[i++];

}

while(i != mid+1)

temp[k++] = source[i++];

while(j != end+1)

temp[k++] = source[j++];

for(i=start; i<=end; i++)

source[i] = temp[i];

}

//内部使用递归

void MergeSort(int source[], int temp[], int start, int end)

{

int mid;

if(start < end)

{

mid = start + (end-start) / 2;//避免溢出int

MergeSort(source, temp, start, mid);

MergeSort(source, temp, mid+1, end);

Merge(source, temp, start, mid, end);

}

}

/*快速排序*/

void QuickSort(int *arr, int maxlen, int begin, int end)

{

int i, j;

if (begin < end) {

i = begin + 1;

j = end;

while (i < j) {

if(arr[i] > arr[begin]) {

swap(&arr[i], &arr[j]);

j--;

} else {

i++;

}

}

if (arr[i] >= arr[begin]) {

i--;

}

swap(&arr[begin], &arr[i]);

QuickSort(arr, maxlen, begin, i);

QuickSort(arr, maxlen, j, end);

}

}

void swap(int *a, int *b)

{

int temp;

temp = *a;

*a = *b;

*b = temp;

}

void Heapify(int *arr, int m, int size)

{

int i, tmp;

tmp = arr[m];

for (i = 2 * m; i <= size; i *= 2) {

if (i + 1 <= size && arr[i] < arr[i+1]) {

i++;

}

if (arr[i] < tmp) {

break;

}

arr[m] = arr[i];

m = i;

}

arr[m] = tmp;

}

void BulidHeap(int *arr, int size)

{

int i;

for (i = size / 2; i > 0; i--) {

Heapify(arr, i, size);

}

}

void swap2(int *arr, int i, int j)

{

int tmp;

tmp = arr[i];

arr[i] = arr[j];

arr[j] = tmp;

}

/*堆排序*/

void HeapSort(int *arr, int size)

{

int i;

BulidHeap(arr, size);

for (i = size; i > 1; i--) {

swap2(arr, 1, i);

Heapify(arr, 1, i - 1);

}

}

/*计数排序*/

void CountSort(int data[],int n)

{

int i,j,count,*data_p;

data_p=(int*)malloc(sizeof(int)*n);

for(i=0;i

data_p[i]=0;

for(i=0;i

{

count=0;

for(j=0;j

if(data[j]

count++;

while(data_p[count]!=0)//对于相等非0的数据，应向后措一位。数据为0时，因数组data_p被初始化为0，故不受影响。

/* 注意此处应使用while循环进行判断，若用if条件则超过三个重复值后有0出现 */

count++;

data_p[count]=data[i];//存放到data_p中的对应位置

}

//用于检查当有多个数相同时的情况

i=0,j=n;

while(i

{

if(data_p[i]==0)

{

int temp=i-1;

data_p[i]=data_p[temp];

}//of if

i++;

}//of while

for(i=0;i

data[i]=data_p[i];

free(data_p);//释放data_p

}

/*桶排序*/

void bucketSort(int *arr, int size)

{

int i,j;

int buckets[size];

memset(buckets, 0, size * sizeof(int));

for (i = 0; i < size; i++) {

buckets[arr[i]]++;

}

for (i = 0, j = 0; i < size; i++) {

while((buckets[i]--) >0)

arr[j++] = i;

}

}

int get_index(int num, int dec, int order)

{

int i, j, n;

int index;

int div;

for (i = dec; i > order; i--) {

n = 1;

for (j = 0; j < dec - 1; j++)

n *= 10;

div = num / n;

num -= div * n;

dec--;

}

n = 1;

for (i = 0; i < order - 1; i++)

n *= 10;

index = num / n;

return index;

}

/*基数排序*/

void RadixSort(int *arr, int len, int dec, int order)

{

int i, j;

int index;

int tmp[len];

int num[10];

memset(num, 0, 10 * sizeof(int));

memset(tmp, 0, len * sizeof(int));

if (dec < order) {

return;

}

for (i = 0; i < len; i++) {

index = get_index(arr[i], dec, order);

num[index]++;

}

for (i = 1; i < 10; i++) {

num[i] += num[i-1];

}

for (i = len - 1; i >= 0; i--) {

index = get_index(arr[i], dec, order);

j = --num[index];

tmp[j] = arr[i];

}

for (i = 0; i < len; i++) {

arr[i] = tmp[i];

}

RadixSort(arr, len, dec, order+1);

}