排序算法之AS3

package {
    import flash.display.Sprite;
    import flash.utils.getTimer;

    public class ActionscriptSortTest extends Sprite {
        //要求將radomArr安從小到大排序
        public function ActionscriptSortTest() {
            initRadomArr();
            
            getBubbleSortArr();
        }
/*        
        冒泡排序是這樣實現的：
           1. 首先將所有待排序的數字放入工作列表中。
           2. 從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。
           3. 重複2號步驟(倒數的數字加1。例如：第一次到倒數第二個數字，第二次到倒數第三個數字，依此類推...)，直至再也不能交換。
        冒泡排序的平均時間複雜度與插入排序相同，也是平方級的，但也是非常容易實現的算法
*/        
        public function getBubbleSortArr():Array {
            var result:Array = radomArr.concat();
            
            fucStart();
            var i:int = 1;
            var j:int = 0;
            var n:int = result.length;
            for(i=1;i<n;i++) {
                for(j=0;j<n-i;j++) {
                    if(result[j] > result[j+1]) {
                        var temp:Number = result[j];
                        result[j] = result[j+1];
                        result[j+1] = temp;
                    }
                }
            }
            
            fucEnd();//17786
            return result;
        }

        private var t:int;
        private function fucStart():void {
            t = getTimer();
        }
        
        private function fucEnd():void {
            trace(getTimer() - t);
        }
        
        private var radomArr:Array;
        private function initRadomArr():void {
            radomArr = [];
            for(var i:int=0;i<10000;i++) {
                radomArr.push(int(Math.random()*0xFFF))
            }
        }
    }
}
 
1.冒泡排序
 
/*        
        冒泡排序是這樣實現的：
        
           1. 首先將所有待排序的數字放入工作列表中。
           2. 從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。
           3. 重複2號步驟(倒數的數字加1。例如：第一次到倒數第二個數字，第二次到倒數第三個數字，依此類推...)，直至再也不能交換。
        
        冒泡排序的平均時間複雜度與插入排序相同，也是平方級的，但也是非常容易實現的算法
        
*/        
        public function getBubbleSortArr():Array {
            var result:Array = radomArr.concat();
            
            fucStart();
            var i:int = 1;
            var j:int = 0;
            var n:int = result.length;
            for(i=1;i<n;i++) {
                for(j=0;j<n-i;j++) {
                    if(result[j] > result[j+1]) {
                        var temp:Number = result[j];
                        result[j] = result[j+1];
                        result[j+1] = temp;
                    }
                }
            }
            
            fucEnd();//17786
            return result;
        }
 
2.插入排序
 
/*        
        一般來說，插入排序都採用in-place在數組上實現。具體算法描述如下：

       1. 從第一個元素開始，該元素可以認爲已經被排序
       2. 取出下一個元素，在已經排序的元素序列中從後向前掃描
       3. 如果該元素（已排序）大於新元素，將該元素移到下一位置
       4. 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置
       5. 將新元素插入到該位置中
       6. 重複步驟2
*/

        public function getInsertionSortArr():Array {
            var result:Array = radomArr.concat();
            fucStart();
            
            var i:int = 1;
            var n:int = result.length;
            
            for(i=1;i<n;i++) {
                var temp:Number = result[i];
                var j:int = i - 1;
                
                while((j>=0) && (result[j] > temp)) {
                                 result[j+1] = result[j];        
                                 j--;
                         }
                         
                         result[j+1] = temp;
            }
            
            fucEnd();
            return result;
        }
 
 
       public function getInsertionSortArr():Array {
            var result:Array = radomArr.concat();
            fucStart();
            
            var i:int = 1;
            var j:int = 0;
            var n:int = result.length;
            
            for(i=1;i<n;i++) {
                for(j=0;j<i;j++) {
                    if(result[j] > result[i]) {
                        var temp:Number = result[j];
                        result[j] = result[i];
                        result[i] = temp;
                    }
                }
            }
            
            fucEnd();
            return result;
        } 
 
        public function getInsertionSortArr():Array {
            var result:Array = radomArr.concat();
            fucStart();
            
            var i:int = 1;
            var j:int = 0;
            var n:int = result.length;
            
            for(i=1;i<n;i++) {
                var temp:Number = result[i];
                for(j=i;j>0 && temp<result[j-1];j--) {
                    result[j]=result[j-1];
                }
                result[j]=temp;
            }
            
            fucEnd();
            return result;
        } 
 
3.快速排序
/*        
快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分爲兩個子序列（sub-lists）。

步驟爲：

   1. 從數列中挑出一個元素，稱爲 "基準"（pivot），
   2. 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割之後，該基準是它的最後位置。這個稱爲分割（partition）操作。
   3. 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

遞迴的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞迴下去，但是這個演算法總會結束，因爲在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。
*/
        
        public function getQuickSortArr():Array {
            var result:Array = radomArr.concat();
            fucStart();
            
            var n:int = result.length;
            quickSort(result,0,n-1);
            
            fucEnd();
            return result;
        }
        
        private function quickSort(arr:Array,low:int,high:int):void {
            var i:int;
            var j:int;
            var x:int;
            
            if (low < high) { //這個條件用來結束遞歸
                
                i = low;
                j = high;
                x = arr[i];
            
                while (i < j) {
                    while (i < j && arr[j] > x) {
                       j--; //從右向左找第一個小於x的數
                    }
                    if (i < j) {
                       arr[i] = arr[j];
                       i++;
                    }
                
                    while (i < j && arr[i] < x) {
                       i++; //從左向右找第一個大於x的數
                    }
                
                    if (i < j) {
                       arr[j] = arr[i];
                       j--;
                    }
                 }

                arr[i] = x;
                quickSort(arr, low, i - 1);
                quickSort(arr, i + 1, high);
            }
        } 
 
 
4.選擇排序
/*
    選擇排序是這樣實現的：
        1.首先在未排序序列中找到最小元素，存放到排序序列的起始位置
        2.然後，再從剩餘未排序元素中繼續尋找最小元素，然後放到排序序列末尾。
        3.以此類推，直到所有元素均排序完畢。
*/
        public function getSelectionSort():Array {
            var result:Array = radomArr.concat();
            
            fucStart();
            var i:int = 0;
            var j:int = 0;
            var n:int = result.length;
            
            for (i = 0; i < n - 1; i++) {
                var min:int = i;
                for (j = i+1; j < n; j++) {
                    if (result[j] < result[min]) {
                        min = j;
                    }
                }
                /* swap data[i] and data[min] */
                var temp:Number = result[i];
                result[i] = result[min];
                result[min] = temp;
            }

            fucEnd();//6214
            return result;
        }
 
 5.雞尾酒排序
 
/*        
        雞尾酒排序，也就是定向冒泡排序, 雞尾酒攪拌排序, 攪拌排序 (也可以視作選擇排序的一種變形), 漣漪排序, 來回排序 or 快樂小時排序, 
        是冒泡排序的一種變形。此算法與冒泡排序的不同處在於排序時是以雙向在序列中進行排序。
*/        
        public function getCocktailSortArr():Array {
            var result:Array = radomArr.concat();
            
            fucStart();
            
            var i:int = 0;
            var n:int = result.length;
            var top:int = n - 1;
            var bottom:int = 0;
            var swapped:Boolean = true; 
            
            while(swapped) { // if no elements have been swapped, then the list is sorted
                swapped = false; 
                var temp:Number;
                for(i = bottom; i < top;i++) {
                    if(result[i] > result[i + 1]) {  // test whether the two elements are in the correct order
                        temp = result[i];// let the two elements change places
                        result[i] = result[i + 1];
                        result[i + 1] = temp;
                        swapped = true;
                    }
                }
                // decreases top the because the element with the largest value in the unsorted
                // part of the list is now on the position top 
                top = top - 1; 
                for(i = top; i > bottom;i--) {
                    if(result[i] < result[i - 1]) {
                        temp = result[i];
                        result[i] = result[i - 1];
                        result[i - 1] = temp;
                        swapped = true;
                    }
                }
                // increases bottom because the element with the smallest value in the unsorted 
                // part of the list is now on the position bottom 
                bottom = bottom + 1;  
            }
            
            fucEnd();//6214
            return result;
        }