快速排序（C++和C#实现）

三、快速排序（O(nlogn)、不稳定）

　　快速排序不稳定指的是在原始序列中相等的元素，按照一定顺序排序后，它们的相对位置可能会发生变化。例如，在快速排序过程中，如果有两个相等的元素A和B，在选取一个数出来分组的时候，如果选到了A，那么在B<=A的情况下，B将会排在A的前面。因为这种可能性存在，所以说这种算法是不稳定的。

举个例子，考虑以下数组：

[5A, 2, 9, 5B, 1]

其中，5A 和 5B 是两个相同的元素，它们的相对位置在排序前是5A在5B前面。但是，在快速排序的过程中，如果基准元素选择的是5A，那么5A和5B的相对位置可能会在排序后发生变化，如下所示：

[1, 2, 5A, 9, 5B]

由于5A和5B的相对位置发生了变化，因此快速排序被认为是不稳定的排序算法。

快速排序简称快排，是一种比较快的排序，适合数据量大，基本无序的数据，为什么这么说呢？下面我说下快排的思路：

思路一：设置两个指针：i和j，分别指向第一个和最后一个，i像后移动，j向前移动。选第一个数为标准（一般这样做，当然快排的关键就是这个“标准”的选取），从后面位置j开始，找到第一个比标准小的数，替换i所在的位置的数，然后i指向i后一个元素，再从位置i开始，找到第一个比标准大的数，替换j所在的位置的数，然后j指向j前一个元素。第一趟的结果就是标准左边的都小于标准，右边的都大于标准（但不一定有序），分成两拨后，继续递归的使用上述方法，最终有序！

void QuickSort(int a[],int left,int right) {
	if (left >= right)
		return;
	int i = left;
	int j = right;
	int key = a[left];
	while (i < j ) {
		while (a[j] >= key && i<j) {
			j--;
	    }
		//如果右边j所在位置的数小于基准数，则替换i所在的位置的数
			a[i] = a[j];
	   
		while (a[i] <= key && i<j) {
			i++;
		}
		//如果左边i所在位置的数大于基准数，则替换j所在的位置的数
			a[j] = a[i];  
	}
	a[j] = key;
	QuickSort(a, left,j-1);
	QuickSort(a, j+1,right);
}

　思路二（跟第一种差不多）：设置两个指针：i和j，分别指向第一个和最后一个，i像后移动，j向前移动，选第一个数为标准（一般这样做，当然快排的关键就是这个“标准”的选取），从后面开始，找到第一个比标准小的数，然后再从前面，找到第一个比标准大的数，互换这两个数的位置，第一趟的结果就是标准左边的都小于标准，右边的都大于标准（但不一定有序），分成两拨后，继续递归的使用上述方法，最终有序！

        快速排序不稳定的原因：

       快速排序有两个方向，左边的i下标一直往右走，直到a[i] > 参考值（p）或者走到数组结尾，参考值一般取为数组第0个元素。
       而右边的j下标一直往左走，当a[j] < 参考值（p）。如果i和j都走不动了，i <= j, 交换a[i]和a[j],重复上面的过程，直到i>j。
       交换a[j]和参考值，完成一趟快速排序。在参考值和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，
       比如序列为 5 3 3 4 3 8 9 10 11， 现在参考值5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，
       所以快速排序是一个不稳定的排序算法，不稳定发生在参考值和a[j] 交换的时刻。

快速排序C#实现：

//快速排序从小到大：
using System;
namespace QuickSort
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[] { 7, 9, 12, 4, 5, 8, 3, 2, 10 };
            QSort(array, 0, 8);
            foreach(int i in array){
                Console.Write("{0} ", i);
            }
        }

        public static void QSort(int[] array,int left, int right)
        {
            //用QSort对子数组快速排序
            //输入：数组A[0,n-1]中的子数组A[left,right],由左右下标left和right定义
            //输出：非降序排列的子数组A[l,r]
            if (left < right)
            {
                int s = Partition(array, left, right);
                QSort(array, left, s - 1);
                QSort(array, s + 1, right);
            }
        }

        public static int Partition(int[] array,int left,int right)
        {
            //以第一个元素为中轴，对子数组进行划分
            //输入：数组A[0,n-1]中的子数组A[l,r],由左右下标l和r定义
            //输出：A[l,r]的一个划分，分裂点的位置为函数的返回值
            int p = array[left];
            int i = left;
            int j = right + 1;
            while (i < j)
            {
                do
                {
                    i += 1;
                }while (array[i] < p && i<array.Length-1);
                do {
                    j -= 1;
                }while (array[j] > p) ;
                Swap(array, i, j);
            }
            Swap(array, i, j);
            Swap(array, left, j);

            return j;
        }
        
        //交换两个数的值
        public static void Swap(int[] array,int i,int j)
        {
            int temp = 0;
            temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }

    }

}