js数组排序

var arr = [12,23,63,10,52,92,11,53,76,9,51,22];

1.冒泡排序

原理：数组中的数据前后两两进行对比，如果后面一个数据小于前面一个则进行交换。

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

2.选择排序

原理：将未排序的数据的第一个数据作为对比基准，在除了已排序和基准数据以外的数据里找到最小的数据，将该数据和基准数据进行交换。

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

3.插入排序

原理：以数组的第一个数据为基准，想象成一个只有一个数据的数组，将剩下的数据依次插入基准数据所在的数组中合适的位置。

for(var i=1;i < arr.length;i++){
    var index = i-1;
    var current = arr[i]
    while(index >= 0 && current < arr[index]){
        arr[index + 1] = arr[index];
        index--;
    }
    arr[index+1] = current
}

4.快速排序

原理：取数组的中间值为基准数据，把数组中剩余的小于基准数据的数据放在基准数据的左边的新数组中，大于的放在右边的新数组中，再分别将这两个新数组按照原数组取中间值，划分左右新数组的方法进行递归，最后即可得到排序好的数组。

function quickSort(arr){
    if(arr.length<=1) return;
    var index = Math.floor(arr.length/2);
    var pivot = arr.splice(index,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])
        }
    }
    console.log(left);
    console.log(right);
    return quickSort(left).concat(pivot, quickSort(right));
}

5.堆排序

原理：利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，即将堆逻辑上存成完全二叉树的形式，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

 var len; //定义成全局变量
function buildHeap(arr) {
    len = arr.length;
    for (var i = Math.floor(arr.length / 2);i>=0; i--) {
        adjustHeap(arr, i)  //调整堆
    }
}

function adjustHeap(arr, i) {
    var left = 2 * i + 1,    // 左节点位置
        right = 2 * i + 2,  //右节点位置
        largest = i; // 最大值位置
    console.log(left+'--'+right)
    console.log(i+'我是i'+largest+'我是largest')

    //如果左节点存在并且左节点大于 当前最大节点，交换位置
    if (left < len && arr[left] > arr[largest]) {
        largest = left
        console.log('执行left')
    }
    if (right < len && arr[right] > arr[largest]) {
        largest = right;
        console.log('执行right')
    }
    //如果发现修改了，则交换位置
    if (largest !== i) {
        swap(arr, i, largest);
        adjustHeap(arr, largest)
    }
    console.log(arr)

}

//交换位置
function swap(arr, i, j) {
    var temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp

}

// 堆排序算法
function heapSort(arr) {
    buildHeap(arr)  //建堆
    for (var i = arr.length - 1; i > 0; i--) {
        swap(arr, 0, i);  //堆顶一定是最大元素，将堆顶和尾部元素交换，最大元素就保存在尾部，并且不参与后面的调整
        len--; //  去掉这个是从大到小排序
        adjustHeap(arr, 0) ///将最大的元素进行调整，将最大的元素调整到堆顶
    }
    return arr
}
heapSort(arr)

6.归并排序

原理：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表

var len = arr.length;
sort(0,len);
function sort(begin,end){
    if(end-begin < 2) {
        return;
    }
    var mid =(begin + end) >> 1;
    sort(begin,mid);
    sort(mid,end);
    merge(begin,mid,end)
}
function merge(begin,mid,end){
    let li = 0,le = mid - begin;
    let ri = mid,re = end;
    let ai = begin;
    let leftArray = [];
    for (let i = li;i < le;i++) {
        leftArray[i] = arr[begin + i];
    }
    while(li < le){
        if(ri < re && arr[ri] < leftArray[li]){
            arr[ai++] = arr[ri++];
        }else{
            arr[ai++] = leftArray[li++];
        }
    }
}