八大排序算法的冒泡排序，快速排序（C实现）

 开局先说一些小概念

什么是排序？

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

什么是稳定性？

 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i] = r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

什么是时间复杂度？

      时间复杂度：算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一 个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。习惯用O（n)渐进表达式

什么是空间复杂度？

       空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度，空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。 空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。

注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因 此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

一，冒泡排序算法

1，思想

非常基础也是非常经典的排序算法，冒泡排序两两进行比较，遍历完一次都会把最大或者最小的元素放在后面，而缺点是，走完一趟只确定了一个数字，整个数组需要走n-1趟。而第一趟时候，需要比较n-1次，第二趟需要比较n-2次........以此类推，外面大循环是n-1次，里面比较大小的循环是n-1-i次。

时间复杂度：O(N^2)；             空间复杂度：O(1);         稳定性：稳定

void bubble_sort(int arr[] ,int sz)
{
	int i = 0;
	int flag = 1;       //优化，要是有序数组，
	for (i = 0; i<sz - 1; i++)        //最好状态，时间复杂度O（n）
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0;
			}
		}
		if (flag == 1)        //要是有序数组
		{
			break;           //跳出大循环
		}
	}
}

二，快速排序

非常重要的排序算法，笔试面试的重点考察知识点！！！！！！

1，思想

      任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int array[], int left, int right)
{
 if(right - left <= 1)
 return;
 

 // 按照基准值对array数组的 [left, right)区间中的元素进行划分
 int div = partion(array, left, right);
 

 // 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
 // 递归排[left, div)
 QuickSort(array, left, div);
 

 // 递归排[div+1, right)
 QuickSort(array, div+1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，同学们在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后续只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两半部分的常见方式有：
hoare法

利用左右两个下标，分别指向头（left）和尾（right），将数组第一个元素设为基准值（key），left往右走去找比key大的值，right往左走去找比key小的值，但是right先走。双方都找到后停止小循环，交换left和right所指向的数组元素值，直到left和right相遇。相遇后交换key和相遇点的元素值，（由于right先走，所以相遇点一定比key值小，所以需要交换值），

单趟排序后，1，key达到他的最终位置，排好了key这个数。2，分割了两个子区间，左右子区间，保证了相遇点左边元素都比他小，右边元素都比他大。所以要right先走是非常必要的。

先走和不先走也是有逻辑的，一，左边第一个作为基准值key，那就右边先走，保证了相遇点比key小。

二，右边第一个作为基准值key，那就左边先走，保证了相遇点比key大。

void Swap(int& a, int& b)  //交换值函数，用的引用
{
	int c = a;
	a = b;
	b = c;
}

int part_sort(int* a, int left, int right)    //单趟排序函数
{
	int keyi = left;
	while (left < right)
	{
		//r找小
		while (left < right && a[right] >= a[keyi])   //left < right 
		{                                             //一定要加，不然可能会错过
			--right;
		}
		//L找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		if (left < right)
		{
			Swap(a[left], a[right]);
		}
	}
		int meeti = left;
	Swap(a[meeti], a[keyi]);
	return meeti;
}
 
void QuickSort(int* a, int begin, int end)   //快速排序函数
{
	if (begin >= end)
	{
		return;
	}
	
	int keyi = part_sort(a, begin, end);
	//[begin,keyi-1]  keyi    [keyi+1,end]

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);

}

复杂度：快排的单趟排序复杂度是O(n),最好的情况每次key都是中间，一共要递归logN次。最坏的情况是O(n^2)，所以总体复杂度是O(N*lonN)。

稳定性：不稳定

改良版本1：三数取中法

优化选择key，主要是针对有序或者接近有序，有序反而复杂度很高，是最坏情况。

用三数取中法，来优化。第一个，中间的，最后一个，选出中间值。

int GetMidIndx(int* a, int left, int right)     //三数取中
{
	int mid = (right + left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

 三数取中之后，刚刚的单趟排序只需要加上这个就行了，达到了优化效果。

void Swap(int& a, int& b)  //交换值函数，用的引用
{
	int c = a;
	a = b;
	b = c;
}

int PartSort(int* a,int left,int right)
{
	 int mid = GetMidIndx(a, left, right);   //
	 Swap(mid, left);
	int keyi = left;
	while (left < right)
	{
		//
		while (left < right && a[right]>= a[keyi])
		{
			--right;
		}
		//
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		if(left<right)
		Swap(a[left], a[right]);
	}
	int meeti = left;
	Swap(a[meeti], a[keyi]);
	return meeti;
}

挖坑法（比heore法好一点）建议兄弟们掌握，可以芜湖起飞

思想：

先让右边先走，找到比key小的值，放进刚刚的坑位之中，而这个数的位置就变成了坑，然后左边再走找到比key大的值，放到右边这个新的坑位之中，以此类推。 

int PartSort2(int* a, int left, int right)   //单趟排序
 {
	 int mid = GetMidIndx(a, left, right);   //用了三数取中法，来优化
	 Swap(mid, left);            //刚刚实现了交换函数，参考上一个代码
	 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;
 }


void QuickSort(int* a, int begin,int end)   //快速排序算法函数
{
	if (begin >= end)                   //调用上面的单趟排序
	{
		return;
	}

	int keyi = PartSort2(a, begin, end);
	//[begin,keyi-1]  keyi    [keyi+1,end]

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);

}

  前后指针法：

设置两个指针，cur找小，prev紧跟着cur，当prev的下一个值不与cur重合时候，prev的值与key的值的关系是大于等于，交换prev++处与cur处的值。以此类推，直到cur走到了末尾后，交换prev和key的值。相当于一直把大于key的值慢慢往后推了。单趟走完，可以达到在prev的左边都比右边要小。

void Swap(int& a, int& b)  //交换值函数，用的引用
{
	int c = a;
	a = b;
	b = c;
}

 
int PartSort3(int* a, int left, int right)
 {
	 int mid = GetMidIndx(a, left, right);   //三数取中法
	 Swap(mid, left);
	 int keyi = left;
	 int prev = left;
	 int cur = left+1;
	 while (cur <= right)
	 {
          //找小
		if(a[cur]<a[keyi] && ++prev!=cur)   //
		 {
            
       Swap(a[prev], a[cur]);
          }

		++cur;
	 }
	 Swap(a[keyi], a[prev]);
	
	 return prev;
 }


void QuickSort(int* a, int begin,int end)   //快排函数
{
	if (begin >= end)
	{
		return;
	}
	
	int keyi = PartSort3(a, begin, end);
	//[begin,keyi-1]  keyi    [keyi+1,end]

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);

}

总结一下：3种方法都是一个目的，单趟排序之后，确定了一个数的位置，以他为基准点。达到左边的一半，都比右边的一半要小。就是左边一半里面最大的数都比右边一半最小的数，要小。

快速排序就是用二叉树递归的思想，再把左边一半当作整体去递归，右边一半当作整体去递归。一直到有序为止。。。。 

重点，快排还有非递归的实现方式，需要用到数据结构----栈，来实现。

那个太复杂，用起来挫挫的，有兴趣的兄弟们，可以去了解一下。应该没人喜欢用那种方法。

兄弟们，下篇博客写直接插入排序和希尔排序。。。。