介绍一下快速排序方法，不能老是用冒泡排序方法。另外一些编程语言也有自己的排序方法，例如：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;
                        }
                        v[low] = v[high];
                        while(low < high && v[low] < key){
                                low+=1;
                        }
                        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;
                        }
                        v[low] = v[high];
                        while(low < high && v[low] > key){
                                low+=1;
                        }
                        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;
                        }
                        v[low] = v[high];
                        while(low < high && v[low] > key){
                                low+=1;
                        }
                        v[high] = v[low];
             }else{
                      while(low < high && v[high] > key){
                                high-=1;
                      }
                      v[low] = v[high];
                      while(low < high && v[low] < key){
                                low+=1;
                      }
                      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 );

本文出自 “Better_Power_Wisdom” 博客，请务必保留此出处http://aonaufly.blog.51cto.com/3554853/1546245

快速排序算法