八大排序的实现及其优化

八大排序

（1）直接插入

void InsertSort(int*a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];

		while (end >= 0)
		{

			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				--end;

				a[end + 1] = tmp;
			}
			else
				break;
		}
	}

}

（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++)
		{
			if (a[i] > a[i + gap])
			{
				Swap(&a[i], &a[i + gap]);
			}
		}
	}
}

（3）选择排序

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

（4）堆排序

void AjustDown(int* a, int n, int root)
{
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (a[child] < a[child + 1] && (child+1)<n)
		{
			++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--)
	{
		AjustDown(a, n, i);
	}
		for (int i = n - 1; i >=0; i--)
		{
			Swap(&a[0], &a[i]);
			AjustDown(a, i, 0);
		}
}

（5）冒泡排序

void BubbleSort(int* a, int n)
{
	int start = 0;
	int exchange = 0;//优化
	while (start < n)
	{
		for (int i = 0; i < n-1; i++)
		{
			if (a[i]>=a[i + 1])
			{
				Swap(&a[i], &a[i + 1]);
				exchange = 1;
			}
		}
		start++;
		if (exchange == 0)
		{
			break;
		}
	}
}

（6）归并排序

void _MergeSort(int* a, int begin, int end,int* tmp)
{
	if (begin >= end)
		return;

	int mid = begin + ((end - begin) >> 1);
	//子问题
	//对[begin，mid]，[mid+1，end]进行排序
	_MergeSort(a, begin, mid,tmp);
	_MergeSort(a, mid + 1, end,tmp);

	int begin1 = begin;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = end;
	int index = begin;
	while (begin1 < end1 && begin2 < end2)
	{
		if (a[begin1] < a[begin2])
			tmp[index++] = a[begin1++];
		else
			tmp[index++] = a[begin2++];

	}
	while (begin1 < end1)
	{
		tmp[index++] = a[begin1++];
	}

	while (begin2 < end2)
	{
		tmp[index++] = a[begin2++];
	}

	index = begin;
	while (begin < end)
	{
		a[begin++] = tmp[index++];
	}
}

void MegeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int)*n);
	_MergeSort(a, 0, n - 1, tmp);

	free(tmp);
}

（7）计数排序

void CountSort(int* a, int n)
{
	int i = 0;
	int max = a[0];
	int min = a[0];
	for (i = 0; i < n; i++)
	{
		if (max < a[i])
			max = a[i];
		if (min > a[i])
			min = a[i];
	}

	int range = max - min + 1;
	int* tmp = (int*)malloc(sizeof(int)*range);
	memset(tmp, 0, sizeof(int)*range);

	for (i = 0; i < n; i++)
	{
		tmp[a[i] - min]++;
	}
	int j = 0;
	for (i = 0; i < n; i++)
	{
		while (tmp[i]--)
		{
			a[j++] = i + min;
		}
	}

}

（8）快排

第一种方法及其优化

int GetMidIndex(int* a, int begin, int end)
{
	int mid = begin + ((end - begin) >> 1);
	if (a[begin] > a[mid])
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[begin] < a[end])
		{
			return begin;
		}
		else
			return end;
	}
	else
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}

int PartSort_1(int* a, int begin, int end)//优化
{
	int mid = GetMidIndex(a, begin, end);

	Swap(&a[mid],&a[begin]);
	int key = begin;
	/*int key = begin;*/
	while (begin < end)
	{
		while (a[begin] < a[end] && a[end] >= a[key])
		{
			--end;
		}
		while (a[begin] < a[end] && a[begin] <= a[key])
		{
			++begin;
		}
		Swap(&a[end], &a[begin]);
	}
	Swap(&a[key], &a[begin]);
	return end;	
}



void QuickSort1(int* a, int begin, int end)
{
	

	if (begin >= end)
	{
		return;
	}
	int div = PartSort_1(a, begin, end);
	QuickSort1(a, begin, div - 1);
	QuickSort1(a, div + 1, end);

}

第二种方法

int PartSort_2(int* a, int begin, int end)
{
	int key = begin;
	while (begin < end)
	{
		while (a[begin] < a[end] && a[end] >= a[key])
		{
			--end;
		}
		a[begin] = a[end];

		while (a[begin] < a[end] && a[begin] <= a[key])
		{
			++begin;
		}
		a[end] = a[begin];
	}

		a[end] = a[key];
		return end;
}



void QuickSort2(int* a, int begin, int end)
{

	if (begin >= end)
	{
		return;
	}
	int div = PartSort_2(a, begin, end);
	QuickSort2(a, begin, div - 1);
	QuickSort2(a, div + 1, end);

}

第三种方法

int PartSort_3(int* a, int begin, int end)
{
	int key = begin;
	int prev = begin;
	int cur = begin + 1;
	while (cur <= end)
	{
		if (a[cur] > a[key])
		{
			++cur;
		}
		Swap(&a[++prev], &a[cur]);
	}
	Swap(&a[key], &a[prev]);

	return prev;
}
void QuickSort3(int* a, int begin, int end)
{

	if (begin >= end)
	{
		return;
	}
	int div = PartSort_2(a, begin, end);
	QuickSort3(a, begin, div - 1);
	QuickSort3(a, div + 1, end);

}

第四种方法

void QuickSortOP(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	if (end - begin > 10)
	{
		int div = PartSort_3;
		QuickSortOP(a, begin, div - 1);
		QuickSortOP(a, div + 1, end);
	}
	else
	{
		InsertSort(a + begin, end - begin + 1);
	}
}