介绍一下快速排序方法，不能老是用冒泡排序方法。另外一些编程语言也有自己的排序方法，例如：AS有sort，在Array中有。但是我顺便说一句：在AS3中，不要轻易使用递归算法，你可以自己做一个Test，当你从1+2+3......一直加到50几的时候（用递归算法），那么程序就会被卡死，在AS3中递归是可行的，但是次数一定不能过多。我之所以把这篇文章写在C#当中，因为快速算法要用到递归。这里多说一句，在AS3中不要用快速排序，因为你很难保证，你的集合的元素数量没有超过AS3递归的界限，那么，在Array中用Sort，在Vector中，我在以前写的“关于AS3中Vector的sort排序”中有，读者可以看看。

首先 ： 来说说思想

    对比与冒泡排序的整体排序，快速排序方法用的是分支排序。

    首先，他有一个基准点（pivot），把pivot的左边的和右边的元素进行整理（当降序排列时，pivot左边的元素>=pivot,右边的元素<=povit,反之亦然），然后再次选择pivot进行排序（递归）

void QuickAscSort( ref vector<int> v, int left, int right){
        if(left < right){
                int key = v[left];
                int low = left;
                int high = right;
                while(low < high){
                        while(low < high && v[high] > key){
                                high-=1;
                        }
                        if(low < high)
                            v[low++] = v[high];
                        while(low < high && v[low] < key){
                                low+=1;
                        }
                        if(low < high)
                            v[high--] = v[low];
                }
                v[low] = key;
                QuickAscSort(v,left,low-1);
                QuickAscSort(v,low+1,right);
        }
}


上面的是一个升序的排列方式

下面是一个降序的方法

void QuickDesSort( ref vector<int> v, int left, int right){
        if(left < right){
                int key = v[left];
                int low = left;
                int high = right;
                while(low < high){
                        while(low < high && v[high] < key){
                                high-=1;
                        }
                        if(low < high)
                         v[low++] = v[high];
                        while(low < high && v[low] > key){
                                low+=1;
                        }
                        if(low < high)
                            v[high--] = v[low];
                }
                v[low] = key;
                QuickDesSort(v,left,low-1);
                QuickDesSort(v,low+1,right);
        }
}



例如 ： [2,5,7,8,9,10,4,6,8,2,3,11,27,12,14,15]   a 的排序

QuickAscSort（ ref a , 0,a.lenght - 1 );   这是一个升序的排列方式 ， 反之亦然。

另外加一个综合的方法 ：

void QuickSort( ref vector<int> v, int left, int right , bool  isAsc ){
     if(left < right){
          int key = v[left];
          int low = left;
          int high = right;
          while(low < high){
             if( !isAsc ){
                        while(low < high && v[high] < key){
                                high-=1;
                        }
                        if(low < high)
                            v[low++] = v[high];
                        while(low < high && v[low] > key){
                                low+=1;
                        }
                        if(low < high)
                            v[high--] = v[low];
             }else{
                      while(low < high && v[high] > key){
                                high-=1;
                      }
                      if(low < high)
                          v[low++] = v[high];
                      while(low < high && v[low] < key){
                                low+=1;
                      }
                      if(low < high)
                          v[high--] = v[low];
            }
          }
          v[low] = key;
          QuickDesSort(v,left,low-1 , isAsc);
          QuickDesSort(v,low+1,right , isAsc);
     }
}

尽情的用吧 ： 升序 QuickSort（ref a , 0 , a.lenght- 1 , true );

                      降序 QuickSort（ref a , 0 , a.lenght- 1 , false );

无法应对 array中有相同值的排序 ----





二,以上方案斗不足以对有多个相同的值的Array进行排序 (会造成混乱)

新的商业方案:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace mY
{
    class Program
    {
        public void QuickSortFunction(int[] array, int low, int high)
        {
            try
            {
                int keyValuePosition;   //记录关键值的下标

                //当传递的目标数组含有两个以上的元素时，进行递归调用。（即：当传递的目标数组只含有一个元素时，此趟排序结束）
                if (low < high)
                {
                    keyValuePosition = keyValuePositionFunction(array, low, high);  //获取关键值的下标（快排的核心）

                    QuickSortFunction(array, low, keyValuePosition - 1);    //递归调用，快排划分出来的左区间
                    QuickSortFunction(array, keyValuePosition + 1, high);   //递归调用，快排划分出来的右区间
                }
            }
            catch (Exception ex)
            { }
        }

        //快速排序的核心部分：确定关键值在数组中的位置，以此将数组划分成左右两区间，关键值游离在外。（返回关键值应在数组中的下标）
        private int keyValuePositionFunction(int[] array, int low, int high)
        {
            int leftIndex = low;        //记录目标数组的起始位置（后续动态的左侧下标）
            int rightIndex = high;      //记录目标数组的结束位置（后续动态的右侧下标）

            int keyValue = array[low];  //数组的第一个元素作为关键值
            int temp;

            //当 （左侧动态下标 == 右侧动态下标） 时跳出循环
            while (leftIndex < rightIndex)
            {
                while (leftIndex < rightIndex && array[leftIndex] <= keyValue)  //左侧动态下标逐渐增加，直至找到大于keyValue的下标
                {
                    leftIndex++;
                }
                while (leftIndex < rightIndex && array[rightIndex] > keyValue)  //右侧动态下标逐渐减小，直至找到小于或等于keyValue的下标
                {
                    rightIndex--;
                }
                if (leftIndex < rightIndex)  //如果leftIndex < rightIndex，则交换左右动态下标所指定的值；当leftIndex==rightIndex时，跳出整个循环
                {
                    temp = array[leftIndex];
                    array[leftIndex] = array[rightIndex];
                    array[rightIndex] = temp;
                }
            }

            //当左右两个动态下标相等时（即：左右下标指向同一个位置），此时便可以确定keyValue的准确位置
            temp = keyValue;
            if (temp < array[rightIndex])   //当keyValue < 左右下标同时指向的值，将keyValue与rightIndex - 1指向的值交换，并返回rightIndex - 1
            {
                array[low] = array[rightIndex - 1];
                array[rightIndex - 1] = temp;
                return rightIndex - 1;
            }
            else //当keyValue >= 左右下标同时指向的值，将keyValue与rightIndex指向的值交换，并返回rightIndex
            {
                array[low] = array[rightIndex];
                array[rightIndex] = temp;
                return rightIndex;
            }
        }
        static void Main(string[] args)
        {
            Program pro = new Program();
            int[] c = new int[] { 1,7,3,5,9,8,2,7,7,8,1,3};
            pro.QuickSortFunction( c, 0, c.Length - 1);
            Console.WriteLine("~~~~~~~~~~~");
            for (int i = 0; i < c.Length; i++)
            {
                Console.WriteLine(c[i]);
            }
            Console.ReadKey();
        }
    }

结果:

wKiom1lgk47B91fDAACYw4GmHo0327.png-wh_50


妥妥的没毛病...........