排序算法

//冒泡排序

// 描述：
// 1.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
// 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
// 3.针对所有的元素重复以上的步骤，除了已排序的最后一个；
// 4.重复步骤1~3，直到排序完成。

function BubbleSort(arr) {
    if (Array.isArray(arr)) {
        var len = arr.length;
        var temp = 0;
        for (var i = 0; i < len - 1; i++) { //外层循环  len - 1次
            for (var j = 0; j < len - 1 - i; j++) { //内层循环  len - 1 - i次  i表示已经排到最后的元素个数
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

//时间复杂度： len * (len - i)
//最坏 O(n^2)    最好 O(n)  

console.log("冒泡排序测试用例：");
var arr = [9, 2, 5, 3, 1, 7, 5];
console.log(arr);

BubbleSort(arr);
console.log(arr);


//选择排序

// 描述：
// 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
// 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 

function SelectSort(arr) {
    if (Array.isArray(arr)) {
        var len = arr.length;
        var minIndex = 0;
        var temp = 0;
        for (var i = 0; i < len; i++) {
            minIndex = i; //minIndex为i的为当前已排序的最后一个元素的索引
            for (var j = i + 1; j <= len; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j; //找到未排序中的最小元素的索引
                }
            }


            //将最小索引元素放到已排序的数组后面  在同一数组中操作
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

console.log("选择排序测试用例：");
var arr2 = [9, 2, 5, 3, 1, 7, 5];
console.log(arr2);

SelectSort(arr2);
console.log(arr2);

//插入排序

//描述：

// 1.从第一个元素开始，该元素可以认为已经被排序；
// 2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
// 3.如果该元素（已排序）大于新元素，将该元素移到下一位置；
// 4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
// 5.将新元素插入到该位置后；
// 6.重复步骤2~5。

//保证 索引 0到index是排序好的

function InsertSort(arr) {
    if (Array.isArray(arr)) {
        var len = arr.length;
        var temp = 0;
        for (var i = 1; i < len; i++) {
            for (var j = i; j > 0 && arr[j - 1] > arr[j]; j--) {
                temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
    }
}

console.log("插入排序测试用例：");
var arr3 = [9, 2, 5, 3, 1, 7, 5];
console.log(arr3);

InsertSort(arr3);
console.log(arr3);


//快速排序

//描述：
//使用分治

// 从数列中挑出一个元素，称为 “基准”；
// 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
// 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

function QuickSort(arr, beginIndex, endIndex) {
    if (Array.isArray(arr)) {
        var len = arr.length;
        var standardValueIndex = 0;
        // var beginIndex = 0;
        // var endIndex = len - 1;

        if (beginIndex < endIndex) {
            standardValueIndex = getStandardValueIndex(arr, beginIndex, endIndex);
            console.log("standardIndex:" + standardValueIndex);
            QuickSort(arr, beginIndex, standardValueIndex - 1);
            QuickSort(arr, standardValueIndex + 1, endIndex);
        }
    }
}

function getStandardValueIndex(arr, beginIndex, endIndex) {

    var tmp = arr[beginIndex];
    while (beginIndex < endIndex) {
        // 当队尾的元素大于等于基准数据时,向前挪动endIndex指针
        while (beginIndex < endIndex && arr[endIndex] >= tmp) {
            endIndex--;
        }
        // 如果队尾元素小于tmp了,需要将其赋值给beginIndex
        arr[beginIndex] = arr[endIndex];
        // 当队首元素小于等于tmp时,向前挪动beginIndex指针
        while (beginIndex < endIndex && arr[beginIndex] <= tmp) {
            beginIndex++;
        }
        // 当队首元素大于tmp时,需要将其赋值给endIndex
        arr[endIndex] = arr[beginIndex];

    }
    // 跳出循环时beginIndexw和endIndex相等,此时的beginIndexw或endIndex就是tmp的正确索引位置
    // 由原理部分可以很清楚的知道beginIndex位置的值并不是tmp,所以需要将tmp赋值给arr[beginIndex]
    arr[beginIndex] = tmp;
    return beginIndex; // 返回tmp的正确位置

}

console.log("快速排序测试用例：");
var arr4 = [9, 2, 5, 3, 1, 7, 5];
console.log(arr4);

var time1 = new Date().valueOf();
QuickSort(arr4, 0, arr4.length - 1);
var time2 = new Date().valueOf();
console.log(time1);
console.log(time2);
var dT = time2 - time1;
console.log("spend " + dT + " ms");
console.log(arr4);