数据结构—排序

一、插入排序
1.直接插入排序：
（1）基本思想：
每一次将一个待排序的元素，按其排序码的大小，插入到已经有序的一组元素的合适位置。直到全部元素插入完成。
（2）代码：

void InsertSort(int *array,int size)
{
	int i = 0;
	for(i = 1;i<size;i++)//第一个元素默认有序
	{
		int key = arr[i];
		int end = i-1;
		while(end >= 0 && key<array[end])//升序,如果end位置比key大，就不停的后移
		{
			array[end+1] = array[end];
			--end;
		}
		array[end+1] = key;//已经找到合适的位置插入key
	}
}

（3）时间复杂度：最好情况为O(n)，最坏情况为O(n^2)。
（4）使用场景：数据少，越接近有序，搬移元素越少，效率也就越高。
（5）稳定性：稳定。
（6）优化：在插入排序的过程中，就重复找位置和搬移元素这两个过程，所以我们可以在找位置的时候使用二分查找来查找。代码实现如下：

void InsertSort_OP(int *array,int size)
{
	int i = 0;
	for(i = 1;i<size;i++)
	{
		int key = array[i];
		int end = i-1;
		int left = 0;
		int right = end;
		while(left <= right)
		{
			int mid = left+(right-left)/2;
			if(key<array[mid])
			{
				right = mid -1;
			}
			else//为了使排序稳定，大于等于都是右边
			{
				left = mid+1;
			}
		}
		while(end>=left)
		{
			array[end+1] = array[end];//已经找到位置，进行搬移数据
			--end;
		}
		array[left] = key;
	}
}

二、希尔排序
1.基本思想：
希尔排序，又称缩小增量排序，是直接插入排序的优化，当数据量特别大的时候，因为直接插入排序的特性，处理起来特别麻烦，我们可以进行等间隔的排序，然后减小间隔，再继续，直至间隔为1。
2：代码

void ShellSort(int *array,int size)
{
	int i = 0;
	int gap = size;
	while(gap>1)
	{
		gap = gap/3+1;
		for(i=gap;i<size;i++)
		{
			int key = array[i];
			int end = i-gap;
			while(end>=0 && key<array[end])
			{
				array[end+gap] = array[end];
				end -= gap;
			}
			array[end+gap] = key; 
		}
	}
}

3.时间复杂度：大概O(n^1.25 ~ 1.6n^1.25)。
4.使用场景：适用数据量较大。
5.稳定性：不稳定–隔着区间插入。
三、选择排序
1.基本思想：每趟在前面（后面）n-i个待排序元素集合中找到最大（最小）的元素，作为有序元素序列的第i个元素，待到第n-2趟做完，待排序元素集合中只剩下一个元素，排序结束。
2.代码：

void Swap(int *x, int *y)
{
	int temp = *x;
	*x = *y;
	*y = temp;
}

void SelectSort(int *array,int size)
{
	int i = 0;
	for(i=0;i<size-1;i++)
	{
		int j = 1;
		int maxPos = 0;//默认待排集合中最大的元素为第一个
		for(;j<size-i;j++)
		{
			if(array[maxPos]<array[j])
				maxPos = j;//maxPos此时记录的是待排序中最大的元素
		}
		if(maxPos != size-i-1)
		{
			Swap(&array[maxPos],&array[size-i-1]);
		}
	}
}

3.时间复杂度：O(n^2)。
4:稳定性：不稳定。
优化：上述算法中，每次之找出最大元素的位置，优化算法中是每次既找到待排集合中最大元素的位置，也找到最小元素的位置。时间复杂度为O(n^2)。

void SelectSort_OP(int *array,int size)
{
	int start = 0;
	int end = size-1;
	while(start<=end)
	{
		int maxPos = start;
		int minPos = start;
		int j = start+1;
		while(j<=end)
		{
			if(array[j]>array[maxPos])
				maxPos = j;
			
			if(array[j]<array[minPos])
				minPos = j;
			
			++j;
		}
		if(maxPos != end)//判断最大的元素的位置是否在此循环最后位置
			Swap(&array[maxPos],&array[end]);
		
		if(minPos == end)//排除最小位置的此次循环的最后位置的特殊情况
			minPos = maxPos;

		if(minPos !=start)
			Swap(&array[minPos],&array[start]);

		++start;
		--end;
	}
}

四、堆排序
1.基本思想：
不管是大堆还是小堆，堆顶元素都是此树中最大的或者最小的元素，这里以升序为例，所以每次将已经建成堆的堆顶元素(最大值)与最后(这里的最后指的是待排序元素的最后一个)一个元素进行交换，再进行向下调整，同时这里引出了一个Top K数据问题，如果要求这个海量数据中的最小的K个值，应该建大堆。

void AdjustDown(int *array, int parent, int size)
{
	int child = (parent << 1) + 1;//默认最大值为左孩子
	while (child<size)
	{
		if (child + 1<size && array[child]<array[child + 1])
			child += 1;

		if (array[parent]<array[child])
			Swap(array[parent], array[child]);

		parent = child;
		child = (parent << 1) + 1;
	}
}

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

2.时间复杂度：O(n*log2^n)。
3.稳定性：不稳定。
五、冒泡排序
1.基本思想：以升序为例，一轮过后最大的值在最后面。

void BubbleSort(int *array,int size)
{
	int i = 0;
	for (i = 0; i < size-1; i++)
	{
		int j = 0;
		int flag = 0;
		for (; j < size - i - 1; j++)
		{
			if (array[j] > array[j + 1])
			{
				Swap(array+j, array+j+1);
				flag = 1;
			}
		}
		if (!flag)
			break;
	}
}

2.时间复杂度：最好为O(n)，最差为O(n^2)。
3.稳定性：稳定。
六、快速排序
1.任取待排序集合中的元素作为基准值，将待排序序列分为两个子序列，做子序列的值均小于基准值，右子序列的值均大于基准值，最后在左右子序列中重复该操作。有三种方式实现该过程。
2.代码：
（1）获取基准值：

int GetMiddleIndex(int *array, int left, int right)
{
	int mid = left + (right - left) / 2;
	if (array[left] < array[right])
	{
		if (array[mid] < left)
			return left;
		else if (array[mid]>array[right])
			return right;
		else
			return mid;
	}
	else
	{
		if (array[mid] < array[right])
			return right;
		else if (array[mid]>array[left])
			return left;
		else
			return mid;
	}
}

（2）交换法：

int Partion1(int *array, int left, int right)
{
	int index = GetMiddleIndex(array, left, right-1);
	int end = right - 1;
	if (end != index)
		Swap(&array[end], &array[index]);

	int key = array[end];
	int begin = left;
	while (begin < end)
	{
		while (begin < end && array[begin] <= key)//从前往后找大于基准值的数
			++begin;

		while (begin < end && array[end] >= key)//从后往前找小于基准值的数
			--end;

		if (begin < end)
			Swap(&array[begin], &array[end]);//交换找到的两个数
	}
	if (begin != right - 1)
		Swap(&array[begin], &array[right - 1]);//如果begin不是最后一个值，就交换begin与基准值
	return begin;
}

（3）挖坑法：

int Partion2(int *array, int left, int right)
{
	int begin = left;
	int end = right - 1;
	int index = GetMiddleIndex(array, left, right-1);
	if (index != end)
		Swap(&array[index], &array[end]);

	int key = array[end];
	while (begin<end)
	{
		while (begin<end && array[begin]<key)//从前往后找大于基准值的begin
			begin++;

		if (begin < end)
		{
			array[end] = array[begin];//用较大的begin覆盖end
			end--;//跳过大于基准值的数
		}

		while (begin<end && array[end]>key)//从后往前找小于基准值的end
			end--;//

		if (begin < end)
		{
			array[begin] = array[end];
			begin++;//跳过小于基准值的数
		}
	}
	array[begin] = key;//最后修改begin指向的值（这里begin和end相等）
	return begin;
}

（4）前后指针法：

int Partion3(int *array, int left, int right-1)
{
	int cur = left;
	int pre = left - 1;
	int index = GetMiddleIndex(array, left, right-1);
	if (index != right - 1)
		Swap(&array[index], &array[right - 1]);

	int key = array[right-1];
	while (cur < right-1)
	{
		if (array[cur] < key)//如果cur指向的值小于基准值，就与下标为pre+1的值交换
		{
			pre++;
			Swap(&array[pre], &array[cur]);
		}
		++cur;//如果找不到小于基准值的cur，就一直往后面找
	}
	if (pre != cur)
		Swap(&array[cur], &array[++pre]);//如果pre与cur指向不同位置，就交换cur与pre+1指向的值

	return pre;
}

（5）排序递归：

void _QuickSort(int *array, int left, int right)
{
	if (right - left > 1)
	{
		int div = Partion3(array, left, right);
		_QuickSort(array, left, div);
		_QuickSort(array, div+1, right);
	}
}

void QuickSort(int *array,int size)//函数调用实现
{
	_QuickSort(array,0,size);
}

3.时间复杂度：
（1）最优情况下为O(n*logn)， 最坏情况下为O(n^2)。
4.适用场景：比较随机的数据。
5.稳定性：不稳定。
七、归并排序
1.基本思想：
将待排序的元素序列分成两个长度相等的子序列，对每一个子序列排序，然后将他们合并成一个序列。
（1）合并：

void MergeData(int *array, int left, int mid, int right, int *temp)
{
	int index = left;
	int begin1 = left;
	int end1 = mid;
	int begin2 = mid;
	int end2 = right;
	while (begin1<end1 && begin2<end2)
	{
		if (array[begin1] <= array[begin2])
		{
			temp[index++] = array[begin1++];
		}
		else
		{
			temp[index++] = array[begin2++];
		}
	}
	while (begin1 < end1)
		temp[index++] = array[begin1++];

	while (begin2 < end2)
		temp[index++] = array[begin2++];

}

（2）递归实现：

void _MergeSort(int *array, int left,int right, int *temp)
{
	if (right - left > 1)
	{
		int mid = left + (right - left) / 2;
		_MergeSort(array, left, mid, temp);
		_MergeSort(array, mid, right, temp);
		MergeData(array, left, mid, right, temp);
		memcpy(array+left, temp + left, sizeof(int)*(right - left));
	}
}

（3）函数接口：

void MergeSort(int *array, int size)
{
	int *temp = (int *)malloc(sizeof(int)*size);
	if (NULL == temp)
	{
		return;
	}

	_MergeSort(array, 0, size, temp);
}

2.时间复杂度：O(n*log2^n)。
3.空间复杂度：O(n)。
4.使用场景：数据量大的情况。
5.稳定性：稳定。
八、基数排序
1.基本思想：基数排序又称鸽巢原理，是对哈希直接定地址的变形应用，先统计相同元素出现的次数，再通过统计的结果将其写入到原来的序列中。

int CountSort2(int *array, int size)
{
	int MinValue = array[0];
	int MaxValue = array[0];
	int i = 0;
	int index = 0;
	for (i=1; i < size; i++)
	{
		if (array[i]>MaxValue)
			MaxValue = array[i];

		if (array[i] < MinValue)
			MinValue = array[i];
	}
	int range = MaxValue - MinValue + 1;//一定要+1
	int *count = (int *)calloc(range, sizeof(int));//calloc这里初始化count为0
	for (i = 0; i < size; i++)
	{
		count[array[i] - MinValue]++;//count的第一个元素即为最小值出现的次数
	}
	
	for (i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			array[index++] = MinValue + i;//按顺序从小到大把数据覆盖到原数组上。
		}
	}
	free(count);
}

2.时间复杂度：O(n)，n为数据个数。
3.空间复杂度：O(m)，m为数据的范围。
4.使用场景：数据大小范围比较集中的情况。
5.稳定性：稳定。