C语言排序

最新推荐文章于 2024-07-11 21:13:07 发布

木公411

最新推荐文章于 2024-07-11 21:13:07 发布

阅读量389

点赞数 9

文章标签：算法数据结构 java

本文链接：https://blog.csdn.net/2302_81226481/article/details/139575362

版权

一.冒泡排序

这个排序方法比较简单，就不必赘述了。

void BubbleSort(int* arr, int size)
{
	int i = 0;
	for (i = 0; i < size - 1; i++)
	{
		int flag = 0;
		int k = 0;
		for (k = 0;k <= size-2-i;k++)
		{
			if (arr[k] > arr[k + 1])
			{
				Swap(arr+k,arr+k+1);
				flag = 1;
			}
		}
		if (0 == flag)
		{
			return;
		}
	}
}

时间复杂度为O（N*2），空间复杂度为O（1）

二.插入排序

//时间复杂度O（N*2）
void InsertSort(int* arr, int size)
{
	int i = 0;
	for (i = 1; i < size; i++)
	{
		int temp = arr[i];
		int end = i - 1;
		while (end >= 0)
		{
			if (temp < arr[end])
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = temp;
	}
}

时间复杂度为O（N*2），空间复杂度为O（1）

三.选择排序

//时间复杂度为O（N*2）
void SelectSort(int* arr, int size)
{
	int begin = 0;
	int end = size - 1;
	while (begin < end)
	{
		int max = begin;
		int min = begin;  
		int i = 0;
		for (i = begin+1;i <= end;i++)
		{
			if (arr[i] > arr[max])
			{
				max = i;
			}
			if (arr[i] < arr[min])
			{
				min = i;
			}
		}
		Swap(arr+begin,arr+min);
		if (max == begin)
		{
			max = min;
		}
		Swap(arr+end,arr+max);
		begin++;
		end--;
	}
}

时间复杂度O（N*2），空间复杂度为O（1）

四.希尔排序

//希尔排序的时间复杂度大致为O（N*1.3）
void ShellSort(int* arr, int size)
{
	int gap = size;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		int i = 0;
		for (i = 0;i <= size-gap-1; i++)
		{
			int end = i;
			int temp = arr[i + gap];
			while (end >= 0)
			{
				if (temp < arr[end])
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = temp;
		}
	}
}

它是先进行预排序，然后在进行插入排序（gap == 1时），这个排序比较难理解，需要大家自己花更多的时间去理解与掌握。

时间复杂度大致为O（N*1.3），空间复杂度为O（1）

五.堆排序

void AdjustDown(int* arr, int up, int down)
{
	int parent = up;
	int child = parent * 2 + 1;
	while (child <= down)
	{
		if (child + 1 <= down && arr[child] < arr[child+1])
		{
			child++;
		}
		if (arr[parent] < arr[child])
		{
			Swap(arr+parent,arr+child);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* arr, int size)
{
	int i = 0;
	for (i = (size - 2) / 2; i >= 0; i--)
	{
		AdjustDown(arr,i,size-1);
	}
	int end = size - 1;
	while (end >= 1)
	{
		Swap(arr,arr+end);
		end--;
		AdjustDown(arr,0,end);
	}
}

这个排序需要大家先掌握堆的知识在来看哦，这样效果会更好。

时间复杂度为O（N*logN），空间复杂度为O（1）

六.归并排序

void _MergeSort(int* arr, int* temp, int left, int right)
{
	if (left == right)
	{
		return;
	}
	int mid = (left + right) / 2;
	_MergeSort(arr,temp,left,mid);
	_MergeSort(arr,temp,mid+1,right);
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int i = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] <= arr[begin2])
		{
			temp[i++] = arr[begin1++];
		}
		else
		{
			temp[i++] = arr[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		temp[i++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		temp[i++] = arr[begin2++];
	}
	memmove(arr+left,temp+left,sizeof(int)*(right-left+1));  
}

//时间复杂度为O（N*logN），空间复杂度为O（N）
void MergeSort(int* arr, int size)
{
	int* temp = (int*)malloc(sizeof(int)*size);
	if (NULL == temp)
	{
		perror("malloc fail");
		exit(1);
	}
	_MergeSort(arr,temp,0,size-1);
	free(temp);
}

时间复杂度为O（N*logN），空间复杂度为O（N）

这个是用递归实现的，还可以用非递归来实现。如下：

void MergeSortNonR(int* arr, int size)
{
	int* temp = (int*)malloc(sizeof(int) * size);
	if (NULL == temp)
	{
		perror("malloc fail");
		exit(1);
	}
	int i = 0;
	int gap = 1;
	while (gap < size)
	{
		for (i = 0; i < size;i += 2*gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			if (begin2 >= size)
			{
				break;
			}
			if (end2 >= size)
			{
				end2 = size - 1;   
			}
			int j = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (arr[begin1] <= arr[begin2])
				{
					temp[j++] = arr[begin1++];
				}
				else
				{
					temp[j++] = arr[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				temp[j++] = arr[begin1++];
			}
			while (begin2 <= end2)
			{
				temp[j++] = arr[begin2++];
			}
			memmove(arr+i,temp+i,sizeof(int)*(end2 - i+1));
		}
		gap *= 2;
	}
	free(temp);
}

七.快速排序

//三数取中
int GetMid(int* arr,int left,int right)
{
	int mid = (left + right) / 2;
	if (arr[left] < arr[mid])
	{
		if (arr[left] > arr[right])
		{
			return left;
		}
		else if (arr[mid] < arr[right])
		{
			return  mid;
		}
		else
		{
			return  right;
		}
	}
	else
	{
		if (arr[mid] > arr[right])
		{
			return mid;
		}
		else if (arr[left] < arr[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

//时间复杂度为O（N*logN） 空间复杂度为O(logN)
void QuickSort1(int* arr, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	if (right-left < 9)
	{
		InsertSort(arr+left,right-left+1);
	}
	else
	{
		int mid = GetMid(arr, left, right);
		Swap(arr + mid, arr + left);
		int begin = left;
		int end = right;
		int key = begin;
		while (begin < end)
		{
			while (begin < end && arr[end] >= arr[key])
			{
				end--;
			}
			while (begin < end && arr[begin] <= arr[key])
			{
				begin++;
			}
			Swap(arr + begin, arr + end);
		}
		Swap(arr + key, arr + begin);
		key = begin;
		QuickSort1(arr, left, key - 1);
		QuickSort1(arr, key + 1, right);
	}
}

//前后指针法
void QuickSort2(int* arr, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	if (right - left < 9)
	{
		InsertSort(arr+left,right-left+1);
	}
	else
	{
		int mid = GetMid(arr,left,right);
		Swap(arr+mid,arr+left);
		int key = left;
		int prev = left;
		int cur = left + 1;
		while (cur <= right)
		{
			if (arr[cur] < arr[key] && ++prev != cur)
			{
				Swap(arr+prev,arr+cur);
			}
			cur++;
		}
		Swap(arr+prev,arr+key);
		key = prev;
		QuickSort2(arr,left,key-1);
		QuickSort2(arr,key+1,right);
	}
}

这里我写了两个版本的快排哦，并且还有三数取中和小区间优化这两个优化哦。

时间复杂度为O（N*logN），空间复杂度为O(logN)

当然还有非递归版本，如下：

void QuickSortNonR(int* arr, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	ST st;
	STInit(&st);
	STPush(&st, right);
	STPush(&st, left);
	while (!STEmpty(&st))
	{
		int left = STTop(&st);
		STPop(&st);
		int right = STTop(&st);
		STPop(&st);
		int mid = GetMid(arr,left,right);
		Swap(arr+mid,arr+left);
		int key = left;
		int prev = left;
		int cur = left + 1;
		while (cur <= right)
		{
			if (arr[cur] < arr[key] && ++prev != cur)
			{
				Swap(arr+prev,arr+cur);
			}
			cur++;
		}
		Swap(arr+prev,arr+key);
		key = prev;
		if (key + 1 < right)
		{
			STPush(&st, right);
			STPush(&st, key + 1);
		}
		if (left < key - 1)
		{
			STPush(&st, key-1);
			STPush(&st, left);
		}
	}
	STDestroy(&st);
}

用到了栈的相关操作哦

八.统计排序

//时间复杂度为O（N+range），空间复杂度为O（range）      
void CountSort(int* arr, int size)
{
	int max = arr[0];
	int min = arr[0];
	int i = 0;
	for (i = 1; i < size; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
		if (arr[i] < min)
		{
			min = arr[i];
		}
	}
	int range = max - min + 1;
	int* count = (int*)calloc(range,sizeof(int));
	if (NULL == count)
	{
		perror("calloc fail");
		exit(1);
	}
	for (i = 0; i < size; i++)
	{
		count[arr[i] - min]++;
	}
	int j = 0;
	for (i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			arr[j++] = i + min;  
		}
	}
	free(count);
}

时间复杂度为O（N+range），空间复杂度为O（range）

大家更多的要自行学习哦，我真的很懒，写得很简略，大家加油哦！