AS3排序

package
{
    import flash.display.Sprite;
    
    public class Sort extends Sprite
    {
        private var arr:Vector.<int>;
        public function Sort()
        {
            arr=new Vector.<int>();
            arr.push(34,50,4,1,68,300,15,32,40,3,20,6);
            trace("排序前:"+arr);
            //BubbleSort();//冒泡排序
            //SelectionSort();//選擇排序
            //QuickSort();//快速排序
            //ShellSort();//希爾排序
            //InsertionSort();//插入排序
            //MergeSort();//歸併排序
            HeapSort();//堆排序
            trace("排序後:"+arr);
            
        }
        
        
        /**
         * 冒泡排序
         * 如設要排序的數組中有N個數據，從 數組第一個數據開始相鄰兩個數據兩兩比較，將大的數據排在小的數據前面，
         * 直到第n-1和第n個比較並排序完成，這樣比較完了一趟排序，第n數是數組中最大的數。 
         * 接着以相同的方法比較從第一個數據起兩兩比較直到第n-2和第n-1比較完成，這樣依次比較的長度遞減直到比較 完成
         * 共須要n-1趟比較。 
         * 
         */
        private function BubbleSort():void{
            var len:int=arr.length;
            for(var i:int=len-1;i>=1;i--){ //冒泡排序每趟比較的最後一位數
                for(var j:int=0;j<i;j++){//每趟都從第一個開始，每趟結束完成arr[i]爲第len-i大
                    if(arr[j]>arr[j+1]){
                        swap(j,j+1);
                    }
                }
            }
        }
        
        /**
         * 選擇排序 
         * 如設要排序的數組中有n個數據,從第1個數據開始先記錄其索引，而後依次與其餘數據比較並更新索引爲最小的索引，
         * 直到比較一趟後將第1個數和記錄索引的數交換
         */
        private function SelectionSort():void{
            var len:int=arr.length;
            var tempIndex:int=0;
            for(var i:int=0;i<len-1;i++){
                tempIndex=i;
                for(var j:int=i+1;j<len;j++){
                    if(arr[tempIndex]>arr[j]){
                        tempIndex=j;
                    }
                }
                if(i!=tempIndex){
                    swap(i,tempIndex);
                }
            }
        }
        
        /**
         *快速排序
         * 快速排序是數組中任意取一個數做爲關鍵數據，數組其餘數與關鍵數據比較，小的放在關鍵數據前面，大的放在關鍵數據
         * 後面，通過一趟後關鍵數據前面的數據都比關鍵數據小，後面的都比關鍵數據大，而後再遞歸比較前面部份和比較後面的部份
         * 數組a[0,n-1],設start爲0,end爲n-1,取start與end的中間數據做爲關鍵數據key
         * 而後將比key小的數放在關鍵數據的前面，比key大的數放在關鍵數據後面,獲得三部分[low]、key、[large],而後再遞歸[low]部分名
         * 和[large]部分
         * 
         * 
         */
        private function QuickSort():void{
            QuickSort2(arr,0,arr.length-1);
        }
        private function QuickSort2(arr:Vector.<int>,start:int,end:int ):void{
            if(start>=end)return;
            var mid:int=int(start+end)/2;
            var key:int=arr[mid];
            var l:int=start;
            var r:int=end;
            while(l<r){
                while(arr[l]<key&&l<end){
                    l++;
                }
                while(arr[r]>key&&r>start){
                    r--;
                }
                if(l<r){
                    swap(l,r);
                }
                
            }
            //swap(l,r);
            if(r-start>1){ 
                QuickSort2(arr,start,r-1);
            }
            if(end-r>1){
                QuickSort2(arr,r+1,end);
            }
            
        }
        
        
        /**
         * 希爾排序
         * 先取一個小於n的整數d1做爲第一個增量，把文件的所有記錄分組。
         * 全部距離爲d1的倍數的記錄放在同一個組中，先在各組內進行直接插入排序；
         * 而後，取第二個增量d2<d1重複上述的分組和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，
         * 即全部記錄放在同一組中進行直接插入排序爲止。
         * 
         */
        private function ShellSort():void{
            var len:int=arr.length;
            var d:int=int(len/2);
            var i:int,j:int,temp:int;
            while(d>=1){
                for(i=d;i<len;i++){
        
                    temp=arr[i];
                    for (j = i; j >= d; j -= d) {  
                        if(temp<arr[j - d]){  
                            arr[j] = arr[j - d];  
                        }else{  
                            break;  
                        }  
                    }   
                    arr[j] = temp;  
                }
                d=int(d/2);
            }
        }
        
        
        /**
         * 插入排序 
         * 插入排序（Insertion Sortion）的基本思想是：把n個待排序的元素當作一個有序表和一個無序表，
         * 開始有序表只包含一個元素，無序表中包含n-1個元素，排序過程當中每次從無序表中取出第一個元素，
         * 把它的排序碼依次與有序表元素的排序碼進行比較，將它插入到有序表中的適當位置，使之成爲新的有序表。
         */
        private function InsertionSort():void{
            var len:int=arr.length;
            var i:int,j:int,insertVal:int;
            for(i=1;i<len;i++){
                insertVal=arr[i];
                for(j=i-1;j>=0;j--){
                    if(insertVal<arr[j]){
                        arr[j+1]=arr[j];
                    }else{
                        break;
                    }
                }
                arr[j+1]=insertVal;
            }
        }
        
        /**
         *歸併排序
         * 歸併排序將已有序的子序列合併造成一個新的有序的序列，而後再將新的有序序列與另一個有序序列合併
         * 直到全部數據都合併排序完成。
         * 
         */
        private function MergeSort():void{
            MergeSort2(0,arr.length-1);
        }
        private function MergeSort2(l:int,r:int):void{
            if(l<r){
                var mid:int=int(l+r)/2;
                MergeSort2(l,mid);
                MergeSort2(mid+1,r);
                Merge(l,mid,mid+1,r);
            }
        }
        
        private var tempArr:Vector.<int>=new Vector.<int>();
        private function Merge(ls:int,le:int,rs:int,re:int):void{
            var l:int=ls;
            var r:int=rs;
            tempArr.length=0;
            while(l<=le&&r<=re){
                if(arr[l]<arr[r]){
                    tempArr.push(arr[l++]);
                    
                }else{
                    tempArr.push(arr[r++]);
                }
            }
            
            while(l<=le){
                tempArr.push(arr[l++]);
            }
            while(r<=re){
                tempArr.push(arr[r++]);
            }
            
            for(var i:int=ls,k:int=0;i<=re&&k<tempArr.length;i++,k++){
                arr[i]=tempArr[k];
            }
        
        }
        
        /**
         *堆排序
         * 一個數組若是符合二叉樹的性質，即非葉子節點均不大於（或不小於）其左右孩子（若存在）結點的關鍵字，則稱爲堆
         * 若是一個序列是堆，而且非葉子節點大於（小於）其子節點則稱爲最大堆（最小堆）
         * 堆排序是利用堆的這一性質去序列進行排序，將一個序列建堆，根節點最大（最小），而後將根節點與最後一個數交換，
         * 除最後一個數以外其他數所造成的序列a[0.....n-2]就可能違反了堆的性質，因此將該序列建堆再將其根節點與a[n-2]交換，
         * 循環建堆交換根節點直到序列排列完成
         * 
         */
        private function HeapSort():void{
            HeapSort1(arr.length);
        }
        
        private function HeapSort1(len:int):void{
            if(len>1){
                BuildHeap(len);
                swap(0,len-1);
                HeapSort1(--len);
            }
        }
        private function BuildHeap(len:int):void{
            
            for(var i:int=(len-1)/2;i>=0;i--){
                maxHeapify(len,i);
            }

        }
        
        /**
         * 比較非葉子節點與左右孩子節點的值，若是節點不全大於左右兩孩子，則將左右孩子中較的數和父節點交換
         * 交換值後可能破壞了被交換的孩子節點子堆性質，所以每次交換以後要從新對被交換的孩子節點進行調整)。
         * 有了初始堆以後就能夠進行排序了。
         * @param len
         * @param index
         * 
         */
        private function  maxHeapify(len:int,index:int):void{
            var ti:int=0,larget:int,l:int,r:int;
            l=getChildLeftIndex(index);
            r=getChildRightIndex(index);
            larget=index;
            if(l<len&&arr[index]<arr[l]){
                larget=l;
            }
            if(r<len&&arr[larget]<arr[r]){
                larget=r;
            }
            if(index!=larget){
                swap(index,larget);
                maxHeapify(len,larget);
            }
        }
        private function getChildLeftIndex(index:int):int{
            return 2*index+1;
        }

        private function getChildRightIndex(index:int):int{
            return 2*(index+1);
        }
        
        /**
         * 交換數組兩位數的數據 
         * @param i
         * @param j
         * 
         */
        private function swap(i:int,j:int):void{
            var temp:int=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
        }
    }
}