排序--快排，归并，希尔排序

1.快速排序

    快速排序，相比于常见的冒泡和选择排序，快速排序的排序速度要相对于较快一点，

    选择和冒泡排序时我们的时间复杂度会固定在o(n^2)的复杂度为了时间减少复杂度，我们可以选择快速排序及其他排序方法。

    对于快速排序，他的算法分析为，先找到基准值，然后通过俩个指针分别从头和尾进行比较。

比如下面这张图：

     在进行快排之前，我们需要取一个数组元素作为我们的基准值，这里我们选择第一个元素作为基准值。我们需要俩个指针，一个指针指向头部我们的基准值位置，另一个指针指向数组尾部。在进行排序时我们要遵循，让数组的前半部分小于我们的基准值，后半部分大于我们的基准值。在本轮排序中，我们先选取 5 作为我们的基准值。然后我们移动尾部指针，直到尾部指针指向的元素小于我们的基准值，我们将此时尾部指针指向的元素填入到我们前指针指向的我们基准值的空位中，然后移动前指针，直到前指针指向的元素大于我们的基准值时，将此时前指针指向的元素填入我们后指针指向的位置。直到俩个指针相遇时(此时指针指向位置必定为空)，将我们的基准值放入位置就完成了本轮排序，然后从最后指针指向的位置再次分开做同样的排序，就可以完成对数组的排序。

 完整代码：

void kuaipai(int *a,int x,int y)
{
if(y - x <= 2)//如果数组只有一个元素或者只有俩个元素直接排序后返回
{
if(y - x <= 1)
{
return ;
}
if(a[x] < a[x+1])
{
swap(a[x],a[x+1]);
}
return ;
}
int z=a[x],l=x,r=y-1;//记录基准值以及俩个指针
while(l < r)//指针未重合时，进行循环
{
while(l < r && z <= a[r])  --r;
if(l < r)  a[l++] = a[r];//当后元素小于基准值时填入空位置中
while(l < r && a[l] >= z) ++l;
if(l < r)  a[r--] = a[l];//当前元素大于基准值时填入空位置
}
a[l]=z;//最后将基准值填入
kuaipai(a,x,l);//再次进行新一轮排序
kuaipai(a,l+1,y);
return ;
}

在完成了快排之后，我们来分析一下，快排的时间复杂度。

快排在进行时最好的情况为每次都可以将数组分为大小基本相同的俩个子数组进行排序，在这种最优的情况下快排的复杂度为n*log(n)。然后我们来考虑，如果每次分组都为，一个数组为一个元素，另一个数组为n-1个元素，如果是这样的话，快排的时间复杂度就为n^2的复杂度。接下来的排序方法可以解决这个问题。

2.归并排序

在快速排序后面，我们发现在最坏的情况下，我们的时间复杂度与选择及冒泡排序并没有太大的差别。问题的关键在于子数组不能被均分，而归并排序则解决了这个问题，因为每次归并都会将子数组分为大小基本相同的俩部分。

我们先来通过一张图了解一下：

 

 从图中我们发现，在归并排序开始时先将数组分为只含一个元素的子数组，然后，对所有的子数组进行合并，合并时进行排序，最终实现对整个数组的排序。在每次进行合并时我们都需要对之前

数组进行存储，然后再拷贝到原数组中。所以每次我们都需要一个临时数组用来进行拷贝。

完整代码：

void hebing(int A[] ,int low,int mid,int height)
{
	int *B = new int[height-low+1];//创建临时数组
	int i = low,j = mid+1,k = 0;//有序数组的头，和临时数组的头，准备进行拷贝
	while(i <= mid && j <= height)//对俩个数组进行排序拷贝
	{
		if(A[i] <= A[j])
		{
			B[k++] = A[i++];
		}
		else{
			B[k++] = A[j++];
		}
	}
	while(i <= mid)//判断是否有漏掉的元素
	{
		B[k++] = A[i++];
	}
	while(j <= height)//判断是否漏掉元素
	{
		B[k++] = A[j++];
	}
	for(int L = low,k = 0;L <= height;L++)//将排好序的临时数组拷贝到原数组对应位置上
	{
		A[L] = B[k++];
	}
	delete[] B;//释放临时数组的占用空间
}
void guibing(int A[] ,int low,int height)
{
	if(low < height)//判断数组长度等于一时直接返回
	{
		int mid = (low+height)/2;//分割数组
		guibing(A,low,mid);//继续分割数组
		guibing(A,mid+1,height);分割数组
		hebing(A,low,mid,height);//对分割后的数组进行排序
	}
	else{
		return ; 
	}
}

在归并排序时，由于我们每次都将数组分为大小基本相同的俩个，所以时间复杂度为n*log(n)

但是在每次排序是我们都要申请临时数组。

3.希尔排序

在希尔排序之前我们先来了解一下插入排序。

插入排序，插入排序就是将数组分为俩部分，分别时已排序区和未排序区。然后，将已排序区的后一个元素，向前插入到已排序区，直到未排序区没有元素为止。

完整代码：

void churu(int *a,int x,int y)
{
for(int i = x + 1;i < y;i++)//依次插入未排序区元素
{
int j = i;
while(j > x && a[j] < a[j-1])//找寻合适的插入位置
{
swap(a[j],a[j-1]);//交换
j-=1;//移动指针
}
}
}

这就是插入排序了，接下来我们来看希尔排序，希尔排序是基于插入排序的一种排序。它可以理解为分组的插入排序。在进行希尔排序时，我们需要选取一个步长，将数组进行分组。按照我们选取的步长序列进行分组并进行插入排序，直到执行步长为1时结束排序。

我们来看下面这张图：

 首先，我们选择以4为步长分数组为4组，每组进行插入排序，然后我们将步长改为2和1对分割的数组再次进行插入排序。最后，我们就得到了一个有序数组。

代码如下：

void churu(int *a,int x,int y，int step)
{
for(int i = x + step;i < y;i+=step)//依次插入未排序区元素
{
int j = i;
while(j > x && a[j] < a[j-step])//找寻合适的插入位置
{
swap(a[j],a[j-step]);//交换
j -= step;//移动指针
}
}
}
void xier(int *a,int x,int y)
{
int k = 0,n = (y - x),step;
do{
step = n / k == 0? 1 : n / k;
for(int i = x,g = y + step;i < g;i++)
{
charu(a,i,y,step);
}
k*=2;
}while(step != 1);
return ;
}

然后，我们来聊一下希尔排序的时间复杂度，对于希尔排序来说它的时间复杂度跟它所选取的步长序列有关，常见的序列有希尔增量序列和Hibbard增量序列。写入增量序列其实就是我们代码中使用的即：n / 2、n / 4 、n / 8 ……它的时间复杂度最坏的情况下是O(n^2)。而Hibbard增量序列的最坏时间复杂度为O(n^1.5)它的规律为：1、3、5、7、……2^k-1。

以上就是我本次分享的排序算法，希望对大家有帮助。