排序的总结

排序的性质

稳定性

相同的值相对顺序不变，对于结构体排序有意义

排序的比较

插入排序：时间复杂度：O(N^2),空间复杂度：O(1),稳定性：稳定

希尔排序：时间复杂度：O(N^1.3),空间复杂度：O(1),稳定性：稳定性：不稳定

选择排序：时间复杂度：O(N^2),空间复杂度：O(1),稳定性：稳定性：不稳定，交换过程中可能改变相同值的位置

堆排序：时间复杂度：O(logN),空间复杂度：O(1),稳定性：稳定性：不稳定

冒泡排序：时间复杂度：O(N^2),空间复杂度：O(1),稳定性：稳定性：稳定

快速排序：时间复杂度：O(logN),空间复杂度：O(logN),稳定性：稳定性：不稳定：单趟排序时可能会改变位置

归并排序：时间复杂度：O(logN),空间复杂度：O(N),稳定性：稳定

        

排序的具体实现

插入排序：

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 (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;
		}
	}
}

选择排序：

void SelectSort(int* a, int n)

{
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int mini = begin, 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;
		}
		Swap(&a[end], &a[maxi]);
		++begin;
		--end;
	}
}

堆排序：

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

void AdjustDown(int* a, int n, int parent)
{
	// 先假设左孩子小
	int child = parent * 2 + 1;

	while (child < n)  // 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--)
	{
		AdjustDown(a, n, i);
	}

	// O(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

冒泡排序：

void BubbleSort(int* a, int n)
{
	for (int j = 0;j < n; j++)
	{
		//单趟
		int flag = 0;

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

快速排序：

int PartSort1(int* a, int left, int right)
{
	// 三数取中
	int midi = GetMidi(a, left, right);
	Swap(&a[left], &a[midi]);

	int keyi = left;
	int begin = left, end = right;
	while (begin < end)
	{
		// 右边找小
		while (begin < end && a[end] >= a[keyi])
		{
			--end;
		}

		// 左边找大
		while (begin < end && a[begin] <= a[keyi])
		{
			++begin;
		}

		Swap(&a[begin], &a[end]);
	}

	Swap(&a[keyi], &a[begin]);
	return begin;
}

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

	int keyi = PartSort1(a, left, right);

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

归并排序 :

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

	int mid = (begin + end) / 2;
	//将区间分为[begin, mid] [mid + 1, end]两个区间,若两区间都有序即可
	_MergeSort(a, tmp, begin, mid);
	_MergeSort(a, tmp, mid + 1, end);

	//归并	
	int begin1 = begin, end1 = mid;
	int begin2 = mid +1, end2 = end;
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	//只有begin1或begin2其中一个结束了才会进入后面的循环.

	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
	memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail!");
	}
	_MergeSort(a, tmp, 0, n - 1);

	free(tmp);
	tmp = NULL;
}

计数排序： 

//时间复杂度:O(N + range),适合整数且范围集中的数据
//空间复杂度：O(range)
void CountSort(int* a, int n)
{
	int min = a[0], max = a[0];
	for (int i = 1; i < n; i++)
	{
		if (a[i] < min)
		{
			min = a[i];
		}
		if (a[i] > max)
		{
			max = a[i];
		}
		int range = max - min + 1;
		int* count = (int*)calloc(range, sizeof(int));
		if (count == NULL)
		{
			perror("calloc fail!");
		}
		//统计次数
		for (int i = 0; i < n; i++)
		{
			count[a[i] - min]++;
		}
		//排序
		int j = 0;
		for (int i = 0; i < n; i++)
		{
			while (count[i]--)
			{
				a[j++] = i + min;
			}
		}

	}
}