快排js实现

/*
    快排js实现
*/

/*
    方法二：
    思路：
    1、选择数组中间数作为基数，并从数组中取出此基数；
    2、准备两个数组容器，遍历数组，逐个与基数比对，较小的放左边容器，较大的放右边容器；
    3、递归处理两个容器的元素，并将处理后的数据与基数按大小合并成一个数组，返回。
*/

    var quickSort = function(arr) {
        　　if (arr.length <= 1) { return arr; }
        　　var pivotIndex = Math.floor(arr.length / 2);
        　　var pivot = arr.splice(pivotIndex, 1)[0];
        　　var left = [];
        　　var right = [];
        　　for (var i = 0; i < arr.length; i++){
            　　　　if (arr[i] < pivot) {
                　　　　　　left.push(arr[i]);
            　　　　} else {
                　　　　　　right.push(arr[i]);
            　　　　}
        　　}
        　　return quickSort(left).concat([pivot], quickSort(right));
    };
/*
    方法二：
    思路：
    1、通过下标取中间数为基数；
    2、从起点往后寻找比基数大的，记录为下标 i；再从终点往前寻找比基数小的，记录为下标 j，当 i <= j时，原地交换数值；
    3、重复步骤2，直到遍历所有元素，并记录遍历的最后一个下标 i，以此下标为分界线，分为左右两边，分别重复步骤1~3实现递归排序；
*/
    var devide_Xin = function (array, start, end) {
        if(start >= end) return array;
        var baseIndex = Math.floor((start + end) / 2), // 基数索引
        i = start,
        j = end;

        while (i <= j) {
            while (array[i] < array[baseIndex]) {
                i++;
            }
            while (array[j] > array[baseIndex])  {
                j--;
            }

            if(i <= j) {
                var temp = array[i];
                array[i] = array[j];
                array[j] = temp;
                i++;
                j--;
            }
        }
        return i;
    }

    var quickSort_Xin = function (array, start, end) {
        if(array.length < 1) {
            return array;
        }
        var index = devide_Xin(array, start, end);
        if(start < index -1) {
            quickSort_Xin(array, start, index - 1);
        }
        if(end > index) {
            quickSort_Xin(array, index, end);
        }

        return array;
    }

/*
    方法三：
    思路：
    1、通过下表取排序区间的第0个数为基数
    2、排序区间基数以后，从右往左，寻找比基数小的，从左往右，寻找比基数大的，原地交换；
    3、重复步骤2直到 i >= j；
    4、将基数与下标为 i 的元素原地交换，从而实现划分；
    5、递归排序基数左边的数，递归排序基数右边的数，返回数组。
*/

    var quickSort_New = function(ary, left, right) {
        if(left >= right) {
            return ary;
        }

        var i = left,
        j = right;
        base = ary[left];

        while (i < j) {
            // 从右边起，寻找比基数小的数
            while (i<j && ary[j] >= base) {
                j--;
            }

            // 从左边起，寻找比基数大的数
            while (i<j && ary[i] <= base) {
                i++
            } 

            if (i<j) {
                var temp = ary[i];
                ary[i] = ary[j];
                ary[j] = temp;
            }
        }

        ary[left] = ary[i];
        ary[i] = base;

        quickSort_New(ary, left, i-1);
        quickSort_New(ary, i+1, right);

        return ary;
    }

    let arr = [2,45,6,778,87,88,76,6]
    quickSort_New(arr,0,arr.length -1);