排序算法

第一种：快速排序

主要思想：通过遍历一次数组，将数组分成独立的两部分，其中一部分的关键字均小于另一部分的关键字，分别对这两部分记录继续进行排序，使整个数组有序。

平均时间复杂度：O(n logn)          空间复杂度：O(logn)             不稳定

   function quickSort(arr) {
        if (arr.length<=1){
            return arr;
        }
        var pivotIndex = parseInt(arr.length/2);
        var pivot = arr.splice(pivotIndex,1)[0];
        var left = [];
        var right = [];
        console.log(pivotIndex);
        console.log(pivot);
        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));
    }
    var a = quickSort([15,9,23,6,24]);
    console.log(a);

第二种：冒泡排序

主要思想：重复遍历要排序的序列，一次比较两个元素，如果顺序错误就进行调整，一直重复这样的工作，将数组中最大的元素一步步下沉到数组的尾部。

平均时间复杂度：O(n^2)              空间复杂度：O(1)              稳定

   function bubbleSort(arr) {
        if(arr.length <= 1) {
            return arr;
        }
        for(var i = 0;i < arr.length;i++) {
            for(var j = 0; j < arr.length-i-1; j++) {
                if(arr[j] > arr[j+1]) {
                    var temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }
    var b = bubbleSort([15,9,23,6,24]);
    console.log(b);

第三种：选择排序

主要思想：首先从待排序数组中选出一个最小的元素，放在数组的起始位置，然后从剩余未排序数组中，选出最小元素，放在以排序序列的尾部，以此类推，直到所有元素排序完成。

平均时间复杂度：O(n^2)             空间复杂度：O(1)              不稳定

   function selectionSort(arr) {
        var minIndex;
        for(var i = 0;i < arr.length;i++) {
            minIndex = i;
            for(var j = i+1;j < arr.length;j++) {
                if(arr[minIndex] > arr[j]) {
                    minIndex = j;
                }
            }
            var temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr;
    }
    var c = selectionSort([3,1,5,3,6,7,2]);
    console.log(c);

第四种：插入排序

主要思想：在未排序的数组中，首先将第一个值与第二个值进行比较，产生有序序列，然后取第三个值与有序序列比较后插入到对应的位置。

平均时间复杂度：O(n^2)          空间复杂度：O(1)            稳定

注：插入排序有两个循环，外循环将数组挨个移动，内循环对外循环选中的元素及它前面的数进行比较。

   function insertionSort(arr) {
        for(var i = 1;i < arr.length; i++) {
            var preIndex = i - 1;
            var current = arr[i];
            while(preIndex >=0 && arr[preIndex] > current) {
                arr[preIndex+1] = arr[preIndex];
                preIndex--;
            }
            //在while循环结束之后，preIndex的值减1，此时arr[preIndex+1] = current，将 
             current值赋给前一位。
            arr[preIndex+1] = current;
        }
        return arr;
    }
    var d = insertionSort([3,1,4,2,6,5]);
    console.log(d);