sort

package com.light.algorithm {
    /**
     * 排序算法合集·
     * @author light
     */
    public class Sort {
        
        private static var len:uint = 0;
        
         /**
         * 冒泡排序 Bubble Sort 
         * 原理:
         * 比较n轮，每一轮都把最大元素移动到数组后端。
         * @return
         */
        public static function bubbleSort(arr:Array):Array {
            len = arr.length;
            for (var i:int = 0; i < len; i++) {
                for (var j:int = i + 1; j < len; j++) {
                    if (arr[i] > arr[j]) {
                        swap(arr, i, j);
                    }
                }
            }
            return arr;
        }
        
         /**
         * 插入排序 Insert Sort
         * 从第二个元素开始，因为左侧的数组为排序后的数组，
         * 只要将当前元素插入到左侧数组的适当位置，就能保持数组为有序
         * 保证左边的是有序的 
         * 然后处理第三个元素...直到最后一个元素
         * @return
         */
        public static function insertSort(arr:Array):Array {
            len = arr.length;
            for (var i:int = 1; i < len; i++) {
                for (var j:int = i; j > 0 && arr[j] < arr[j - 1]; j--) {
                    swap(arr, j, j -1);
                }
            }
            return arr;
        }
        
        /**
         * 折半搜索插入排序 BinarySearchThenInsert Sort
         * 原理与插入排序类似，不同点在于寻找插入位置的时候，采取的是折半查找方法
         * @return
         */
        public static function binsertSort(arr:Array):Array {
            len = arr.length;
            for (var i:int = 1; i < len; i++) { 
                if (arr[i] < arr[0]) { 
                    var temp:int = arr[i];
                    for (var j:int = i - 1; j >= 0; j--) { 
                        arr[j + 1] = arr[j];
                    }
                    arr[0] = temp;
                } else if (arr[i] < arr[i - 1]) { 
                    var larrange:int = 0;
                    var rarrange:int = i - 1;
                    while (rarrange - larrange > 1) {
                        var p:int = (rarrange + larrange + 1) / 2;
                        if (arr[i] < arr[p]) { 
                            rarrange = p;
                        } else {
                            larrange = p;
                        }
                    }
                    temp = arr[i];
                    for (j = i - 1; j >= larrange + 1; j--) { 
                        arr[j + 1] = arr[j];
                    }
                    arr[larrange + 1] = temp;
                }
            }
            return arr;
        }
        
        /* 堆排序 Heap Sort
         * 利用了堆的易调整的特点来进行的一种选择排序。
         * 以大顶堆为例，什么是大顶堆？
         * 大顶堆的逻辑结构是一颗完全二叉树，[把满二叉树最后一层右侧的一些叶子摘掉]
         * 假设其高度为h，则元素个数介于
         * 1 + 2 + ... + exp(2, h - 2) ~ 1 + 2 + ... + exp(2, h -1)之间
         * 符合如下定义为大顶堆：(此定义基于大顶堆的顺序存储结构)
         * for (int i = arr.length - 1; i > 0; i--) {
         *         任意 arr[i] <= arr[(i - 1)/2];
         * }
         * (还有一种是小顶堆，不同的只是比较时候的大于号方向不同)。
         * 容易想到，当堆顶元素(MaxValue)被替换后，
         * 至多只要在双亲和子节点间进行h（大顶堆的高度） - 1次交换，
         * (参照交换算法可以发现比较次数一般来说是交换次数的2~3倍，也不算多)
         * 就可以形成新的大顶堆。由此大大提高了排序效率。
         * @return
         */
        public static function heapSort(arr:Array):Array {
            // 初始化无序数组为大顶堆
            for (var i:int = arr.length - 2; i >= 0; i--) {
                adjustHeap(arr, i, arr.length - 1);
            }
            // 将最大值元素交换至数组末端，并调整前端为大顶堆，循环直至前端只剩下一个元素
            for (i = arr.length - 1; i > 0; i--) {
                swap(arr, 0, i);
                adjustHeap(arr, 0, i - 1);
            }
            return arr;
        }
        
        /**
         * 将除顶(不确定是否满足大顶堆条件)外，左子树和右子树都为一个堆的数组调整为大顶堆
         * @param arr 待调整数组
         * @param from 顶的指针
         * @param to    调整的末端(就是调整array[from]...arr[to]这一段为一个大顶堆)
         */
        private static function adjustHeap(arr:Array, from:int, to:int):void {
            var i:int = 0;
            // 比较节省比较次数的方法，只要比较到比其左右子树的根结点的值都大，就可以return了
            while (from + 2 * i + 2 <= to) {
                if (arr[from + i] < arr[from + 2 * i + 1]
                     || arr[from + i] < arr[from + 2 * i + 2]) {
                    if (arr[from + 2 * i + 1] > arr[from + 2 * i + 2]) {
                        swap(arr, from + i, from + 2 * i + 1);
                        i += i + 1;
                    } else {
                        swap(arr, from + i, from + 2 * i + 2);
                        i += i + 2;
                    }
                } else {
                    return;
                }
            }
            if (from + 2 * i + 1 == to
                    && arr[from + i] < arr[from + 2 * i + 1]) {
                // 有时会出现仅存在左子树的情况(左子树为调整数组的最后一个元素)
                swap(arr, from + i, from + 2 * i + 1);
            }
        }
        
        /**
         * 快速排序 Quick Sort
         * 选择数组中的一个元素作为标准，将所有比标准小的元素放到左边，
         * 所有比标准大的元素放到右边。
         * 并对左边和右边的元素做一样的快速排序过程。
         * @return
         */
        public static function quickSort(arr:Array):Array {
              quick(arr, 0, arr.length - 1);
              return arr;
        }

        /**
         * 选择数组中的一个元素作为标准，将所有比标准小的元素放到左边，
         * 所有比标准大的元素放到右边。
         * 并对左边和右边的元素做一样的快速排序过程。
         * @param arr
         * @param startIndex
         * @param endIndex
         */
        private static function quick(arr:Array, startIndex:int, endIndex:int):void {
            var pIndex:int = startIndex;
            for (var i:int = startIndex + 1; i <= endIndex; i++) {
                if (arr[i] < arr[pIndex]) {
                    var temp:int = arr[i];
                    for (var j:int = i; j > pIndex; j--) {
                        arr[j] = arr[j - 1];
                    }
                    arr[pIndex] = temp;
                    pIndex++;
                }

            }
            if (pIndex - startIndex > 1) {
                quick(arr, startIndex, pIndex - 1);
            }
            if (endIndex - pIndex > 1) {
                quick(arr, pIndex + 1, endIndex);
            }
        }
        
        /**
         * 希尔排序 Shell Sort
         * <p>原理：
         * 分别以数组大小的1/2,1/4,1/8....1的作为步伐d，
         * 将array[i],arr[i + d],arr[i + 2d]....arr[i + nd]看作一个数组进行排序，
         * 与插入排序相比，因为可以更有效的消除逆序，因此交换次数是很少的，
         * 缺点是比较次数过多
         * @return
         */
        public static function shellSort(arr:Array):Array {
            len = arr.length
            for (var d:int = len / 2; d > 0; d = d / 2) { 
                for (var i:int = d; i < len; i++) { 
                    for (var j:int = i; j >= d; j = j - d) { 
                        if (arr[j] < arr[j - d]) { 
                            swap(arr, j, j - d);
                        }
                    }
                }
            }
            return arr;
        }
        
        /**
         * 简单选择排序 SimpleSelection Sort
         * <p>原理：每遍历未排序部分一次都选出一个最小值，并将最小值元素移动到数组前端
         * @return
         */
        public static function simpleSelectionSort(arr:Array):Array {
            // 重复此过程：选取最小值，并将其交换至数组前端
            var minIndex:int = 0;
            for (var i:int = 0; i < arr.length; i++) {
                minIndex = i;
                for (var j:int = i + 1; j < arr.length; j++) {
                    if (arr[j] < arr[minIndex]) {
                        minIndex = j;
                    }
                }
                swap(arr, minIndex, i);
            }
            return arr;
        }
        
        /**
         * 归并排序 Merge Sort
         * <p>原理：
         * 分治。将数组分为左，右两部分，
         * 首先将数组分为左右两部分，分别进行归并排序，
         * 然后合并左右两部分的排序结果就构成了一个有序数组。
         * @return
         */
        public static function mergeSort(arr:Array):Array {
            mergeR(arr, 0, arr.length - 1);
            return arr;
        }

        /**
         * 递归对数组进行归并排序
         * @param arr
         * @param startIndex
         * @param endIndex
         */
        private static function mergeR(arr:Array, startIndex:int, endIndex:int):void {
            if (startIndex < endIndex) {
                var mid:int = (startIndex + endIndex) / 2;
                // 对包括中点在内的左侧数组区间进行归并排序
                mergeR(arr, startIndex, mid);
                // 对中点之后的右侧数组区间进行归并排序
                mergeR(arr, mid + 1, endIndex);
                // 合并左和右两个独立的有序区间为一个有序区间
                merge(arr, startIndex, mid, endIndex);
            }
        }

       /**
         * 将array数组的两个有序区间array[startIndex]...arr[midIndex]
         * 和array[midIndex + 1]...arr[endIndex]合并为一个有序区间
         * arr[startIndex]...arr[endIndex]
         * @param arr
         * @param startIndex
         * @param midIndex
         * @param endIndex
         */
        private static function merge(arr:Array, startIndex:int, midIndex:int, endIndex:int):void {
            var arrTemp:Array = new Array(endIndex - startIndex + 1);            
            var pr:int = 0;
            var p1:int = startIndex;
            var p2:int = midIndex + 1;
            while (p1 <= midIndex || p2 <= endIndex) {
                if (p1 == midIndex + 1) {
                    while (p2 <= endIndex) {
                        arrTemp[pr++] = arr[p2++];
                    }
                } else if (p2 == endIndex + 1) {
                    while (p1 <= midIndex) {
                        arrTemp[pr++] = arr[p1++];
                    }
                } else if (arr[p1] <= arr[p2]) {
                    arrTemp[pr++] = arr[p1++];
                } else {
                    arrTemp[pr++] = arr[p2++];
                }
            }
            for (p1 = startIndex, p2 = 0; p1 <= endIndex; p1++, p2++) {
                arr[p1] = arrTemp[p2];
            }
        }
        
        /**
         * 交换。。。
         * @param    arr
         * @param    i
         * @param    j
         */
        private static function swap(arr:Array, i:int, j:int):void {
            var temp:int = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        
    }

}