js数组排序

算法：
冒泡排序：
概念：比较两个相邻的元素，如果前面的数大于后面的数，则交换位置

function maoPaoOrder(arr) {
            for(var i = 0; i < arr.length-1; i++) {
                for(var j = 0; j < arr.length-1-i;j++) {
                    if(arr[j] > arr[j+1]) {
                        arr[j] = arr[j] + arr[j+1];
                        arr[j+1] = arr[j] - arr[j+1];
                        arr[j] = arr[j] - arr[j+1];
                    }
                }
            }
        }

选择排序：
概念：从数组的开头开始，将第一个元素和其他元素进行比较，检查完所有元素后，最小的元素会放在数组的第一个位置，然后算法会从第二个位置继续。这个过程一直进行，当进行到数组的倒数第二个位置时，所有的数据便完成了排序

function selectSort(arr) {
            var len = arr.length
            var minIndex, tem
            for (var i = 0; i < len; j++) {
                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
            }
            return arr
        }
        var arr  = [0,5,2]
        console.log(selectSort(arr));

插入排序：
概念：把一个数插入到有序数组中，从后向前依次对比，如果待插入的数小于对比的那个数，向前移动，带插入的数大于对比的那个数就插入到对比的那个数后面

 for(var i = 1; i < arr.length; i++) {
            var num = arr[i];
            var j = i -1;
            while(j >= 0 && arr[j] > num) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j+1] = num;
        }
        console.log(arr);

快速排序：数组中指定一个元素作为标尺，比它大的放到该元素后面，比它小的放到该元素前面，如此重复直至全部正序排列。
快速排序分三步：
1、从数组的中间选择一项作为主元。
2、创建两个指针，left指向数组的第一个元素，right指向数组的最后一个元素，移动left指针直到找到第一个比主元大的数，接着在移动right指针，找到比元主小的数，交换他们，重复这个过程，直到左右指针相遇。在这个过程执行完主元左边都是比主元小的数，主元的右边都是比主元大的数。划分
3、接着对划分后的两个小数组重复之前的操作，直至数组已经全部排列
2.使用两个数组进行存放

function QuickSort() {
                const array = [];
                this.insert = function(item) {
                    array.push(item);
                }
                this.toString = function() {
                    return array.join();
                }
                this.quickSort = function() {
                    quick(array,0, array.length-1);
                }
                const quick = function(array, left, right) {
                    let index = 0;
                    if(array.length > 1) {
                        index = partition(array, left, right) {
                            if(left < index-1) {
                                quick(array, left, index-1);
                            }
                            if(index < right) {
                                quick(array, left, right);
                            }
                        }
                    }
                    const partition = function(array, left, right) {
                        var pivot = array[Math.floor((left + right) / 2)],
                        i = left,
                        j = right;
                        while(i <= j) {
                            while(array[i] < pivot) {
                                i++
                            }
                            while(array[j] > pivot) {
                                j--;
                            }
                            if(i <= j) {
                                swapQuickSort(array, i, j);
                                i++;
                                j--;
                            }
                        }
                        return i;
                    }
                    const swapQuickSort = function(array, index1, index2) {
                        var aux = array[index1];
                        array[index1] = array[index2];
                        array[index2] = aux;
                    }
                }
                var arr = new QuickSort();
            }

快速排序：
概念：确定中间一个数，然后比中间数小放左边数据，比中间大的放右边数组

var arr = [12,3,45,34,32,22,8,6,49];
            function quickOrder(arr) {
                if(arr.length <= 1) {
                    if(arr.length <= 1) {
                        return arr;
                    }
                    var num = parseInt(arr.length/2);
                    var temp = [arr[num]];
                    var arrLeft = [], arrRight = [];
                    for (var i = 0; i < num; i++) {
                        if(arr[i] < temp[o]) {
                            arrLeft.push(arr[i]);
                        }else {
                            arrRight.push(arr[i]);
                        }
                    }
                    for(var j = num + 1; j < arr.length; j++) {
                        if(arr[j] < temp[0]) {
                            arrLeft.push(arr[j]);
                        }else {
                            arrRight.push(arr[j]);
                        }
                    }
                    return quickOrder(arrLeft).concat(temp,quickOrder(arrRight));
                }
                console.log(quickOrder(arr));
            }