十大排序(C语言版)

目录

_1.桶排序

_2.归并排序

_3.计数排序

_4.基数排序

_5.堆排序

_6.插入排序 

_7.希尔排序 

_8.选择排序

_9.冒泡排序 

_10.快速排序 

---

桶排序

void BucketSort(int* a, int n)
{
	int b[100] = { 0 };
	for (int i = 0; i < n; i++)
		b[a[i]]++;
	int j = 0;
	for (int i = 0; i < 100; i++)
	{
		if (b[i]--)
		{
			a[j++] = i;
		}
	}
}

 一般情况在数据量最大最小值相差很大的话，桶排序浪费的空间会大幅增加，是一种空间换时间的算法排序

-------------------------------------------------------------------------------------------------------------------------------- 

归并排序

void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left >= right)
		return;
	int mid = (left + right) / 2;
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int i = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
	memcpy(a + left, tmp + left, (right - left + 1) * sizeof(int));
}
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		return;
	}
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
}

归并排序核心就是将两个有序数组合并成一个 有序数组，利用分治的思想能够很好的实现

归并操作的工作原理如下：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针超出序列尾

将另一序列剩下的所有元素直接复制到合并序列尾

---------------------------------------------------------------------------------------------------------------------------------

 计数排序

void CountSort(int* a, int n)
{
	int min = a[0];
	int max = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] < min)
			min = a[i];
		if (a[i] > max)
			max = a[i];
	}
	int range = max - min + 1;
	int* tmp = (int*)malloc(sizeof(int) * range);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		return;
	}
	memset(tmp, 0, sizeof(int) * range);
	for (int i = 0; i < n; i++)
	{
		tmp[a[i] - min]++;
	}
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (tmp[i]--)
		{
			a[j++] = i + min;
		}
	}
}

也是一种牺牲 空间换时间的算法 时间复杂度下限为O(nlogn),适合数据较为集中且重复率比较高

---------------------------------------------------------------------------------------------------------------------------------

 基数排序

#include<bits/stdc++.h>
using namespace std;
 
int temp[100];
int bucket[10];
 
int maxBit(int data[],int n)
{
	//行这些代码在求n个元素的最大值 
	int maxData = data[0];
	for(int i=1;i<n;i++)
	{
		if(maxData<data[i])
			maxData=data[i];
	}
	
	//这些代码在求最大值的位数是多少 
	int d=1;    //d用来计数最大值的位数，因为既然是一个数，肯定至少有1位，所以d初始化为1 
	while(maxData>=10)  //将最大值不断/10，计算位数 
	{
		maxData/=10;
		d++;
	}
	return d;
} 
void radixsort(int data[],int n)  //基数排序 
{
	int d = maxBit(data,n);  //求出最大位数
	int i,j,k;
	int radix = 1;
	for(i=1;i<=d;i++)   //进行d次排序
	{
	    for(j=0;j<10;j++)   //每次分配前清空计数器
		{
			bucket[j]=0;
		}
		for(j=0;j<n;j++)    //统计每个桶的元素个数 
		{
			k=(data[j]/radix)%10;
			bucket[k]++;
		}

	    for(j = 1; j < 10; j++)
            bucket[j] = bucket[j - 1] + bucket[j]; 

		for(j = n-1; j>=0; j--) 
        {
            k = (data[j] / radix) % 10;
            temp[bucket[k] - 1] = data[j];
            bucket[k]--;
        }
        for(j = 0; j < n; j++)
            data[j] = temp[j];
            
        radix = radix * 10;   
	} 
}

 --------------------------------------------------------------------------------------------------------------------------------

 堆排序

void swap(int* a, int* b)
{
	int as = *a;
	*a = *b;
	*b = as;
}
void AdjustUp(int* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		parent = (child - 1) / 2;
		if (a[parent] > a[child])
		{
			swap(&a[parent], &a[child]);
			child = parent;
		}
		else
		{
			break;
		}
	}
}
void AdjustDown1(int* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] < a[child])
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}

 向上向下调整都可以实现队列排序，数据量大的话向下调整会稍微快一点

-------------------------------------------------------------------------------------------------------------------------------- 

插入排序 

void InsetSort(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

-------------------------------------------------------------------------------------------------------------------------------- 

希尔排序 

void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		for (int i = 0; i < n-gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp > a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

 希尔排序可以理解成进行多次插入排序，多增加的预排序让数组越趋向于有序，这样当gap=1时候进行的插入排序就非常快速了

 --------------------------------------------------------------------------------------------------------------------------------

选择排序

void Swap(int* a, int* b)
{
	int s = *a;
	*a = *b;
	*b = s;
}
void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		int mini = begin, maxi = begin;
		for (int i = begin; i <= end; i++)
		{
			if (a[i] > a[maxi])
				maxi = i;
			if (a[i] < a[mini])
				mini = i;
		}
		Swap(&a[begin], &a[mini]);
		Swap(&a[end], &a[maxi]);
		begin++, end--;
	}
}

---------------------------------------------------------------------------------------------------------------------------------

冒泡排序 

void BubbleSort(int* a, int n)
{
	for (int i = 1; i <= n - 1; i++)
	{
		int flag = 0;
		for (int j = 0; j <= n - 1 - i; j++)
		{
			if (a[j] > a[j + 1])
			{
				flag = 1;
				int temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
		if (flag == 0)
		{
			break;
		}
	}
}

--------------------------------------------------------------------------------------------------------------------------------

快速排序 

void quick_sort(int q[], int l, int r)
{
    if (l >= r) return;

    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while (i < j)
    {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。

(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。

(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

(4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了

--------------------------------------------------------------------------------------------------------------------------------