七大经典排序算法

1.冒泡排序

基本方法：比较相邻两个数，如果前者比后者大，则进行交换。每一轮交换结束，会有一个最大的数放在数组的最后面，经过N-1轮，排序完成。

oid Bubble_Sort(int* a, int size)
{
	int temp = 0;
	for (int i = 0; i < size - 1; i++)
	{
		for (int j = 0; j < size - 1 - i; j++)
		{
			if (a[j] > a[j + 1])
			{
				temp = a[j+1];
				a[j+1] = a[j];
				a[j] = temp;			
			}
		}
	}
}

2.选择排序

基本方法：依次选出数组最小的数放到数组的前面。首先从数组的第二个元素开始往后遍历，找出最小的数放到第一个位置。再从剩下数组中找出最小的数放到第二个位置。以此类推，直到数组有序。

void Select_Sort(int* a, int size)
{
	
	int MinIndex = 0;
	for (int i = 0; i < size - 1; i++)
	{
		MinIndex = i;//记录下当前最小值的下标
		for (int j = i+1; j < size ; j++)
		{
			if (a[j] < a[MinIndex])
			{
				MinIndex = j;//最小值的下标交换
			}
		}
		if(MinIndex != i)
		{
			int temp = 0;
			temp = a[i];
			a[i] = a[MinIndex];
			a[MinIndex] = temp;
		}		 
	}
}

3.直接插入排序

基本方法：每一步将一个待排序的元素，按其排序码的大小，插入到前面已经排好序的一组元素的合适位置上去，直到元素全部插完为止。

void DirInsert_Sort(int* a,int size)
{
	int j = 0;
	int temp = 0;
	for (int i = 1; i < size; i++)
	{

		 j = i - 1;
		 temp = a[i];
		while (j >= 0 && a[j] > temp)
		{
			a[j + 1] = a[j];//将数据整体向后调整
		    j--;
	    }
		a[j + 1] = temp;//将当前轮次的指定数放到合适的位置
	}

}

4.希尔排序（缩小增量排序）

基本方法：先将整个代拍元素序列切割成若干个子序列（由相隔某个“增量”元素的组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，等到整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

void  Shell_Sort(int* a,int size)
{
	int j = 0;
	int temp = 0;
	int gap = size;
	int i = 0;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		for (i = gap; i < size; i++)
		{
			temp = a[i];
			for (j = i - gap; j >= 0; j -= gap)
			{
				if (temp < a[j])
					a[j + gap] = a[j];
				else
					break;

			}
			a[j + gap] = temp;

		}
	}
}

5. 快速排序

基本方法：设置两个哨兵变量left和right，为确保参考值的左边都小于右边，先让right从右边开始扫描，扫描到第一个小于参考值的地方，停下来，让left从左边开始扫描，扫描到第一个大于参考值的地方，停下来，将left和right所在的数据交换，如果left和right相遇，则本轮扫描结束，将参考值放到合适的位置上（left==right），然后递归处理当前参考值左边的序列和右边的序列。

void Quick_Sort(int* a,int begin,int end )
{
	int i = begin;
	int j = end;
	int key = a[begin];
	if (begin >= end)
	{
		return;
	}
	while (i < j)
	{
		while (a[j] >= key && i < j)//当出现第一个大于参考值的数，停止
			j--;
		while (a[i] <= key && i < j)//当出现第一个小于参考值的数，停止
			i++;
		if (i < j)
			swap(&a[i], &a[j]);//交换left和right的值
	}
	 a[begin] = a[i];
	 a[i] = key;//参考值放到中间
	 if(begin <= i - 1)
		 Quick_Sort(a, begin, i-1);
	 if(end >= j + 1)
	     Quick_Sort(a, j+1,end);
		 return;

}

6.堆排序

基本方法：将初始待排序关键字序列构成大堆，此堆为初始的无序区；将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区（R1----Rn-1），由于交换后新的堆顶R[1]可能违反堆得性质，因此，要对(R1-----Rn-1)进行调整。不断重复此过程直到有序区元素个数为n-1，则排序完成。

void percDown(int* a, int i, int N)
{
	int child;
	int temp;
	for (temp = a[i]; 2*i+1 < N; i = child)
	{
		child = 2 * i+1;//数组下标是从0开始的，所以做孩子的球阀不是2*i
		if (child != N -1&& a[child + 1] > a[child])
			child++;    //找到最大的儿子节点
		if (temp < a[child])
			a[i] = a[child];
		else
			break;
	}
	a[i] = temp;
 
}
void Heap_Sort(int* a, int N)
{
	int i = 0;
	//i从N/2开始是因为这样N/2->N都是0-N/2的儿子
	for (i = N / 2; i>=0; i--)		//将数组调整为最大堆
	{
		percDown(a, i, N); //调整i元素的位置
	}
	for (i = N - 1; i>0; i--)
	{
		swap(&a[0], &a[i]);	//a[0]就是最大值，将最大值放到最后的位置上
		percDown(a, 0, i);	//然后重新调整a[0]的位置，这里只需要调整0到i的堆
	}
}

7.归并排序

基本思想：把长度为n的输入序列分成两个长度为n/2的子序列，对这两个子序列分别采用归并排序，将两个排序好的子序列合并成一个最终的排序序列。

void merge(int* a, int low, int mid, int high)
{
	int i = 0;
	int k = 0;
	int* temp = (int*)malloc((high - low + 1)*sizeof(int));
	int left_low = low;
	int left_high = mid;
	int right_low = mid + 1;
	int right_high = high;
	for (k = 0; left_low <= left_high && right_low <= right_high; k++)
	{
		if (a[left_low] <= a[right_low])
		{
			temp[k] = a[left_low++];/假如左边的最小下标值小则放入temp空间中
		}
		else
		{
			temp[k] = a[right_low++];//假如右边的最小下标值小则放入temp空间中
		}
	}
	if (left_low <= left_high)
	{
		for (i = left_low; i <= left_high; i++)
			temp[k++] = a[i];//假如左边有剩余则全部依次放入temp空间中
	}
	if (right_low <= right_high)
	{
		for (i = right_low; i <= right_high; i++)
			temp[k++] = a[i];//假如右边有剩余则全部依次放入temp空间中
	}
	for (i = 0; i < high - low + 1; i++)
	{
		a[low+i] = temp[i];//将排好序的数据放回a中
	}
	
	free(temp);//释放temp空间
	return；
}
void merge_sort(int* a, int first, int last)
{
	int mid = 0;
	if (first < last) 
	{
		mid = (first + last) / 2;
		merge_sort(a, first, mid);//递归划分左边的数据
		merge_sort(a, mid + 1, last);//递归划分右边的数据
		merge(a, first, mid, last);
	}
}