[关于排序]

排序的种类

排序主要分为以下几种:

冒泡排序
插入排序
选择排序
堆排序
希尔排序
快速排序
归并排序

其中冒泡排序与选择排序只具备教学意义,实用性不高

冒泡排序

分别两两比较,最终得出有序数列

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

插入排序

先将前[0,end]位置看做有序,后从end+1位置开始向前插入,最终有序

//插入排序
void InsertSort(int* a, int n)
{
	for(int i=0;i<n-1;i++)
	{
		int end=i;
		//[0,end]是有序的要把end+1位置的值插入,[0,end]保持有序
		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 selectSort(int* a, int n)
{
	int beg = 0;
	int end = n - 1;
	while (beg < end)
	{
		int max_i = beg;
		int min_i = beg;
		for (int i = beg + 1; i <= end; i++)
		{
			if (a[i] > a[max_i])
			{
				max_i = i;
			}
			if (a[i] < a[min_i])
			{
				min_i = i;
			}
		}
		Swap(&a[beg], &a[min_i]);
		if (beg == max_i)
			max_i = min_i;
		Swap(&a[end], &a[max_i]);
		beg++;
		end--;
	}
}

堆排序

运用二叉树中的向上\下排列来建堆,后完成排序

void Swap(int*p1,int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void adjustup( int* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}

	}

}
void adjustdown(int* a, int n, int parent)
{
	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 = 1; i < n; i++)
	{
		//建堆
		adjustup(a, i);
	}
	int end = n - 1;
	while (end > 0)//降序排列
	{
		Swap(&a[0], &a[end]);
		adjustdown(a, end, 0);
		--end;
	}
}

希尔排序

分为两步
1.预排序
先定义一个gap(每次排列的大小)
gap越大可以越快跳到后面, 小的数可以越快跳到前面, 越不接近有序
gap越小 跳的越慢 但越接近有序 当gap==1时相当于插入排序
2.插入排序

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;
			//[0,end]是有序的要把end+1位置的值插入,[0,end]保持有序
			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时相当于插入排序

快速排序

先定义一个key
从左右分别开始找
左边后找比key大的
右边向前找比key小的
都找到后两者交换
两种相遇后与两者交换

int GetMidi(int* a, int left, int right)
{
	int midi = (left + right) / 2 ;
	if (a[left] < a[midi])
	{
		if(a[midi]<a[right])
		{
			return midi;
		}
		else if (a[left] < a[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	else //a[left] > a[midi]
	{
		if (a[midi] > a[right])
		{
			return midi;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}

	}
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;

	if ((right - left + 1) < 10)
	{
		InsertSort(a + left, right - left + 1);
	}
	else
	{
		//三数取中
		int midi = GetMidi(a, left, right);
		Swap(&a[left], &a[midi]);


		int keyi = left;
		int beg = left;
		int end = right;

		while (beg < end)
		{
			while (beg < end && a[end] >= a[keyi])
			{
				end--;
			}
			while (beg < end && a[beg] <= a[keyi])
			{
				beg++;
			}
			Swap(&a[beg], &a[end]);
		}
		Swap(&a[keyi], &a[beg]);
		keyi = beg;

		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
	
}

归并排序

先将数组分为两组,都有序后合并(需要创建额外数组)

void _MergeSort(int* a, int*tmp, int beg, int end)//子函数
{
	if (beg == end)
		return;

	int mid = (beg + end) / 2;
	//如果[beg,mid] [mid+1,end]都有序则可以进行归并
	_MergeSort(a, tmp, beg, mid);
	_MergeSort(a, tmp, mid + 1, end);

	int beg1 = beg; int end1 = mid;
	int beg2 = mid + 1; int end2 = end;
	int i = beg;
	//有一个结束就结束
	while (beg1<=end1 && beg2<=end2)
	{
		if (a[beg1] < a[beg2])
		{
			tmp[i++] = a[beg1++];
		}
		else
		{
			tmp[i++] = a[beg2++];

		}
	}
	//一个结束后,将另一个全部插入
	while (beg1 <= end1)
	{
		tmp[i++] = a[beg1++];
	}
	while (beg2 <= end2)
	{
		tmp[i++] = a[beg2++];
	}

	//将对应位置的tmp放入a中
	memcpy(a+beg, tmp+beg, (end - beg + 1) * sizeof(int));
}
//归并排序
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if(tmp==NULL)
	{
		perror("malloc");
		return;
	}

	_MergeSort(a, tmp, 0, n - 1);

	free(tmp);
	tmp = NULL;
}