排序数组（八大常见排序实现）

按时间性能分

o(n*logn)的排序：快排，归并，堆排序；

o(n2)的排序：直接插入，选择，冒泡排序；

还有一个不确定的希尔排序；

1.直接插入排序

算法思想：很简单，类似于摸扑克牌，在有序的数字区间内插入一个数字，仍让它有序；

代码实现：

void insertsort(int *a, int n)
{
	for (int i = 1; i < n; i++)
	{
		int end = i - 1;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}

			a[end + 1] = tmp;
		}
	}
	





}

时间复杂度分析：

最好：本身就是有序的，此时只需比较n-1次，时间复杂度为O（N）；

最坏：数组是逆序的时候，是一个等差数列O(N2)

2.希尔排序

希尔排序是插入排序的改进版本；

算法思想：让数据更快的跳入到后面，先对数组进行预排序，使他接近有序，再用直接插入排序对它进行排序；

代码实现：

void shellsort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		//gap /= 2;
		gap = gap / 3 + 1;

		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[i + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

时间复杂度：

稳定性：希尔排序是一种不稳定的排序；

eg 3 5 10 8 7 2 8 1 20 6 

若 gap=2,则一趟下来的排序为 

3 1 7 2 8 5 10 6 20 8

3.简单选择排序

简单选择排序是一种最朴实无华的算法，选出最大的值放到右边，最小的值放到左边，也可以说是最low的算法

代码实现

void SelectSort(int* a, int n)
{
	int left = 0, right = n - 1;
	while (left < right)
	{
		int mini = left, maxi = left;
		for (int i = left + 1; i <= right; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}

			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}

		swap(&a[left], &a[mini]);
		// 如果left和maxi重叠，交换后修正一下
		if (left == maxi)
		{
			maxi = mini;
		}

		swap(&a[right], &a[maxi]);

		++left;
		--right;
	}
}

 时间复杂度O(N2）

选择排序是一种不稳定的排序；

4.冒泡排序

算法思想：两两之间相互比较交换，达到排序目的；

代码实现；

void bubbleSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		bool flag = false;
		for (int i = 1; i < n-j; i++)
		{
			if (a[i] < a[i - 1])
			{
				swap(&a[i - 1], &a[i]);
				flag = true;

			}
		}
		if (flag == false)
		{
			break;
		}
	 }



}

时间复杂度：

最好：有序时，只需比较N-1次，O（N)

最坏：逆序时等差数列O(N2）；

5.堆排序

堆是一种常见的数据结构——完全二叉树；

算法思想：排升序，建大堆

建堆方式：向上调整建堆（模拟插入过程）；向下调整建堆；

堆排序
void HeapSort(int* a, int n)
{
	//建堆；
	for (int i = 1; i < n; i++)
	{

		AdjustUp(a, i);

	}
	//向下调整建堆；
	/*for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{

		AdjustDown(a, n, i);

	}*/
	//模拟删除过程排序；
	int end = n - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}

}

向上建堆时间复杂度O(N*logN),向下调整时间复杂度O(N)

模拟删除过程排序时间复杂度O(N*logN);

堆排序时间复杂度O(N*logN);

堆排序是不稳定的；

6.快速排序

最牛逼的排序要不，要不然怎么叫快排呢；

算法思想，类似与数组划分，选出一个基准值，小于基准值的调到左边，大于基准值的调到右边；

实现方法有hoare版本，挖坑法，双指针法，三路划分法；

//快速排序   平均N*logn   最坏接近有序n的平方；
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;//只有一个值，或区间不存在则返回；

	int keyi = PartSort3(a, left, right);
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}
//hoare版本
int PartSort1(int* a, int left, int right)
{
	int begin = left, end = right;
	int keyi = left;
	while (left < right)
	{    //右边找小；
		while (left<right && a[left]>=a[keyi])
		{
			left++;
		}
		//左边找大
		while (left < right && a[left] <= a[keyi])
		{
			right--;
		}
		//交换；
		swap(&a[left], a[right]);


	}
	swap(&a[keyi], a[left]);
	keyi = left;
	return keyi;




}
//挖空法
int PartSort2(int* a, int left, int right)
{
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		// 右边找小
		while (left < right && a[right] >= key)
			--right;

		a[hole] = a[right];
		hole = right;

		// 左边找大
		while (left < right && a[left] <= key)
			++left;

		a[hole] = a[left];
		hole = left;
	}

	a[hole] = key;

	return hole;
}
//前后指针法,数组划分；
int PartSort3(int* a, int left, int right)
{
	int keyi = left;
	int prev = left;
	int cur = left + 1;
	
	for (cur = left + 1; cur <= right; cur++)
	{
		if (a[cur] < a[keyi])

		{
			prev++;
			swap(&a[prev], &a[cur]);
		}

	}
	swap(&a[keyi], &a[prev]);
	keyi = prev;
	return keyi;
}

平均时间复杂度O(N*logN)，最坏接近有序O(N的平方）；

快速排序是一种不稳定的算法；

7.归并排序

分治的思想，选一个中间值，使它左区间有序，右区间有序，返回的时候合并两个有序数组；

代码实现：

class Solution {
    public int[] sortArray(int[] nums) {
     mergesort(nums,0,nums.length-1);
     return nums;
    }


  public void mergesort(int[]nums,int left,int right)
  {
    if(left>=right)
    {
        return;
    }
   int mid=(left+right)/2;
   mergesort(nums,left,mid);
   mergesort(nums,mid+1,right);
   int[]tmp=new int[right-left+1];
   int i=0,cur1=left,cur2=mid+1;
   while(cur1<=mid&&cur2<=right)
   { 
    tmp[i++]=nums[cur1]<=nums[cur2]?nums[cur1++]:nums[cur2++];
   }
  while(cur1<=mid)  tmp[i++]=nums[cur1++];
  while(cur2<=mid)   tmp[i++]=nums[cur2++];
    for(int j=left;j<=right;j++)
    {
        nums[j]=tmp[j-left];
    }
   
  }

}

时间复杂度O(N*logN)

归并排序是一种稳定的排序；

8.总结；