介绍一下快速排序方法,不能老是用冒泡排序方法。另外一些编程语言也有自己的排序方法,例如: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


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