C语言实现排序算法

直接插入排序时间复杂度O（N^2），空间复杂度O（1），最好情况是有序或接近有序，最差情况是逆序，有序时比希尔排序更好

希尔排序（缩小增量排序，其优化了直接插入排序）中，gap（一般为3）越大，前面大的数据可以越快到后面，后面小的数可以越快到前面。缺点是gap越大越不接近有序，若gap=1等于直接插入排序。希尔排序时间复杂度O（N^1.3~N^2）

选择排序时间复杂度O（N^2），最坏情况是有序时非常慢

交换函数

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

插入排序

// 直接插入排序
void InsertSort(int* a, int n)//把end+1向[0，end]中插入
{
	assert(a);
	for (int i = 0; i < n - 1; ++i)//注意范围控制,n-1是最后一个数下标
	{
		int end=i;//先把第一个数当成有序，然后不断插入数据
		int tmp = a[end + 1];//tmp是需要插入的数据
		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>1相当于预排序，让数组接近有序
	{
		gap = gap / 3 + 1;//+1保证最后一次gap一定是1，这时相当于直接插入排序
		//为什么边界是n - gap？ 因为它后面没有足够的间距排序了，++i控制多组并排
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i; 
			int tmp = a[end + gap];//把tmp看作是插入的数据进行排序
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;//回退到前一个排序的数据
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}	
	}
}

堆排序

// 堆排序
void AdjustDwon(int* a, int n, int root)//排升序建大堆，降序建小堆
{
	int parent=root;
	int child=parent*2+1;
	while (child < n)
	{
		if (child + 1 < n && 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 HeapSort(int* a, int n)
{
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDwon(a, n, i);
	}
	
	int end = n - 1;
	while (end > 0)//现在排的是升序
	{
		Swap(&a[0], &a[end]);//建堆选出最大的数在a[0]，放到最后
		AdjustDwon(a, end, 0);//再把次大的数放到倒数第二个位置，以此类推
		--end;//每次调整的范围都减1
	}
}

选择排序

// 选择排序
void SelectSort(int* a, int n)//在[begin,end]中找出最大和最小的数的下标，一次选两个数
{
	assert(a);
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int mini, maxi;
		mini = maxi = begin;
		for (int i = begin + 1; i <= end;++i)//遍历一遍找出最大和最小的数
		{
			if (a[i] > a[maxi])
			{
				maxi = i;
			}

			if(a[i]<a[mini])
			{
				mini = i;
			}
		}
		Swap(&a[begin], &a[mini]);//把小的数放在前面
		if (begin == maxi)//若maxi和mini位置重叠，则maxi位置需要修正！
		{
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);//把大的数放在后面

		//缩小范围
		begin++;
		end--;
	}
}

计数排序

//时间复杂度O（N+range），空间复杂度O（range），只适用整形，若是浮点数或字符串排序用比较排序
void CountSort(int* a, int n)
{
	assert(a);
	int max = a[0];
	int min = a[0];
	for (int i = 1; i < n; i++)
	{
		if (a[i] > max)
			max = a[i];

		if(a[i]<min)
			min = a[i];
	}

	int range = max - min + 1;//范围是最大值-最小值+1
	int* countArr = (int*)malloc(sizeof(int) * range);//统计数据的数组
	memset(countArr, 0, sizeof(int) * range);//将数组初始化为0

	for (int i = 0; i < n; i++)//统计次数
	{
		countArr[a[i] - min]++;
	}

	int index = 0;
	for (int j = 0; j < range; j++)//排序用相对位置，节省空间
	{
		while (countArr[j]--)
		{
			a[index++] = j + min;
		}
	}
	free(countArr);
}

代码测试

void PrintArray(int* a, int n)//打印数据
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

void TestInsertSort()
{
	int a[] = { 1,0 ,5,2,1,4,6,3,2,5,4,8,9};
	PrintArray(a, sizeof(a) / sizeof(int));
	InsertSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestShellSort()
{
	int a[] = { 10,9,0,7,6,4,4,7,2,1,7 };
	PrintArray(a, sizeof(a) / sizeof(int));
	ShellSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestSelectSort()
{
	int a[] = { 10,9,7,7,4,5,9,3,2,1,7 };
	PrintArray(a, sizeof(a) / sizeof(int));
	SelectSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestHeapSort()
{
	int a[] = { 10,9,8,7,4,5,4,3,7,1,7 };
	PrintArray(a, sizeof(a) / sizeof(int));
	HeapSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestCountSort()
{
	int a[] = { 10,9,8,7,6,5,4,5,8,9,10,4,6,8,7};
	PrintArray(a, sizeof(a) / sizeof(int));
	CountSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

int main()
{
	//TestInsertSort();  //直接插入
	//TestShellSort();  //希尔排序
	//TestSelectSort(); //选择排序
	//TestHeapSort();   //堆排序
	//TestCountSort();  //计数排序
	return 0;
}