交换排序：冒泡排序和快速排序

交换排序分为冒泡排序和快速排序。

冒泡排序：

    它是一种比较简单的排序方法，相邻两个元素两两比较，如果后一个比前一个大，就交换，每趟排序都可以将大的元素“浮”到顶端。外层循环循环n-1次，相当于排好了最大的n-1个元素的位置，则最后一个元素的位置就确定了。内层循环循环n-i次，两两交换，第一次排出最大元素在a[n-1]处；第二次循环n-1次，最大元素在a[n-2]处。

时间复杂度：

最好的情况：有序的，需要进行n-1次比较，O(n)

最坏的情况：逆序的，第一趟进行n-1次比较，第二趟进行n-2次比较，......进行1次比较。总共需要n*(n-1)/2次比较，则时间复杂度为O(n^2)

算法稳定性：

冒泡排序是将小的元素调到前面，大的元素调到后面。相邻两元素比较，交换，相等就不交换，因此算法的是稳定的。

 

void BubbleSort(int a[],size_t n)
{
	int i,j,temp;
	for(i = 0;i < n-1;++i) //进行n-1次外层循环
	{
		for(j = 0;j < n-1-i;++j)
		{
			if(a[j] > a[j+1])
			{
				temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp;
			}
		}
	}	
}

void TestBubbleSort()
{
	int a[] = {12,23,6,9,18,22,35,120,89,67};
	BubbleSort(a,sizeof(a)/sizeof(a[0]));
	PrintArray(a,sizeof(a)/sizeof(a[0]));
}

运行结果：

 

快速排序：

      设要排序的数组为a[0],a[1],a[2],a[3],......,a[n-1]，任取一个数据作为关键字（通常是数组的第一个元素），一趟快速排序下来，比它大的数放在它的前面，比它小的数放在它的后面，对左右区间重复快排，直到各区间只有一个数。

时间复杂度：

最好的情况：若数组有n个元素，算出支点key的位置，再递归调用左半部分和右半部分，第一层递归 n/2 ,n/2 ,第二层递归 4/n ,4/n ,4/n ,4/n ，则n个元素递归共需x层 ：2^x = n , x=logn , 每层都是n的复杂度，则时间复杂度为O(nlogn)。

最坏的情况：有序数组，则比较次数为n-1+n-2+n-3+……+1=n(n-1)/2=O(n^2)

快速排序是不稳定的一种算法，两个相同的值在排序过程中的先后顺序有可能改变。

代码实现：

快速排序（左右指针法）

begin为左指针，end为右指针

//[begin,end]
int Partition(int* a,int begin,int end)
{
	int& key = a[end]; //key是a[end]的别名，使用引用更高效
	while(begin < end)
	{
		while(begin < end && a[begin] <= key)
			++begin; //begin找大

		while(begin < end && a[end] >= key)
			--end; //end找小

		if(begin < end)
			swap(a[begin],a[end]);
	}
        //当出了循环，begin=end时，此时a[begin]一定大于key，a[begin]和key交换，key就在“中间”的位置
        swap(a[begin],key);
	return begin;
}

void QuickSort(int* a,int left,int right)
{
    if(left >= right)
        return;
    int div = Partition(a,left,right); //div是选出来的关键数字，其左边的数比它小，右边的数字比他大
    QuickSort(a,left,div-1); 对div左右两边的区间再进行快排
    QuickSort(a,div+1,right);
}

void TestQuickSort()
{
    int a[] = {12,17,18,3,9,7,4,29,53,6};
    //int a[] = {7,4,21,8,16,19,20,9,10};
    QuickSort(a,0,sizeof(a)/sizeof(a[0])-1);
    PrintArray(a,sizeof(a)/sizeof(a[0]));
}

运行结果：

改进：快速排序（左右指针法）

对于支点key的选取----采用三数取中法，使key两边的数更加接近五五分。

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

//左右指针法[left,right]
int Partition(int* a,int begin,int end)
{
	int mid = GetMidIndex(a,begin,end);
	swap(a[mid],a[end]);

	int& key = a[end];
	while(begin < end)
	{
		//begin找大
		while(begin < end && a[begin] <= key)
			++begin;

		while(begin < end && a[end] >= key)
			--end;
		//end找小

		if(begin < end)
			swap(a[begin],a[end]);
	}
	swap(a[begin],key);
	return begin;
}

快速排序（挖坑法）

begin找比key大的数，把a[begin]赋给a[end]，begin处为新坑，end找比key小的数，a[end]赋给a[begin]，end处为新坑。

//挖坑法[left,right]
int Partition(int* a,int begin,int end)
{
	int& key = a[end];
	while(begin < end)
	{
		while(begin < end && a[begin] >= key)
			++begin;

		if(begin < end)
			a[end] = a[begin];

		while(begin < end && a[end] <= key)
			--end;
		
		if(begin < end)
			a[begin] = a[end];
	}
	a[begin] = key;
	return begin;
}

快速排序（前后指针法）

int Partition(int* a,int left,int right)
{
	int prev = left-1;
	int cur = left;
	while(cur < right)
	{
		if(a[cur] < a[right] && ++prev !=cur)
		{
			swap(a[cur],a[prev]);
		}
		++cur;
	}
	swap(a[right],a[++prev]);
	return prev;
}