算法

 

一，排序

 

1.冒泡

 

let ary=[3,1,4,6,5,2,0,7];

let len=ary.length;

for(let i=0;i<len-1;i++){

    for(let j=i+1;j<len;j++){

        if(ary[i]>ary[j]){

            [ary[i],ary[j]]=[ary[j],ary[i]];

        }

    }

}

 

2.快速：递归取中值，对比分左右 https://segmentfault.com/a/1190000009426421

 

var quickSort = function(arr) {

    if (arr.length <= 1) { return arr; }

    //基准数

    var pivot = arr.splice(0, 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),pivot,...quickSort(right)];

};

 

3.选择：两次遍历，得最小索引，两两交换 https://segmentfault.com/a/1190000009366805

 

function selectionSort(arr) {

    let len = arr.length;

    let minIndex;

    for (let i = 0; i < len - 1; i++) {

        minIndex = i;

        for (let j = i + 1; j < len; j++) {

            if (arr[j] < arr[minIndex]) {

                minIndex = j;

            }

        }

        [arr[i],arr[minIndex]]=[arr[minIndex],arr[i]];

    }

    return arr;

}

 

4.希尔：晕，学过，忘了，以后再说  https://segmentfault.com/a/1190000009461832

 

// arr=[1,2,3,4,5,6,7]

function shellSort(arr) {

    var len = arr.length,

        temp,

        gap = 1;

    while(gap < len/3) { 

        gap = gap*3+1; //4

    }

    for (gap; gap > 0; gap = Math.floor(gap/3)) { //1

        for (var i = gap; i < len; i++) {

            temp = arr[i];

            for (var j = i-gap; j >= 0 && arr[j] > temp; j -= gap) {

                arr[j+gap] = arr[j];

            }

            arr[j+gap] = temp;

        }

    }

    return arr;

}

 

//shell ，余数分割。先将数组分成几段，每一段都是混沌的，然而段与段之间都是有秩序的；剩下的便是一一交换。

//间隔，也就是段的长度，是逐步递减的

function sortE(ary){

    var sp=5;

    var len=ary.length;

    //设置一个初始记录值

    var h=1;

    while(h<len/sp){

        h=sp*h+1; //设置间隔

    }

    //h 是从4 开始计算， 自上而下以3为间隔的循环

    while(h>=1){

        //从起始值向后循环数组

        for(var i=h; i<len; i++){

            for(var j=i; j>=h && ary[j]<ary[j-h]; j-=h){ 

                swap(ary, j, j-h);

            }

        }

        h=(h-1)/sp;

        //console.log('ary: '+ary);

        console.log('h: '+h);

    }

    return ary;

}

 

i=6

j=6 j-6=0 

 

i=7

j=7 j-6=1

 

i=15

j=15 j-6=9

j=9 j-6=3

 

 

5.sort 排序

 

ary.sort((a,b)=>{return (a > b)?1:-1;})

 

 

二，堆栈、队列、链表 

https://juejin.im/entry/58759e79128fe1006b48cdfd 

https://www.cnblogs.com/justSmile2/p/9778498.html

 

1.堆栈：

栈遵循先进后出原则，是用于存放基本数据和对象的索引的，

堆是用于存放对象的实际数据的。

 

2.队列：遵循先进先出的原则

 

3.链表：链表的元素在内存中不是有序放置的，它的每个元素由存储元素本身的节点和一个指向下一个元素的引用组成。其元素的增删不会移动其它元素。

 

三，递归

https://segmentfault.com/a/1190000009857470

 

 

四，波兰式和逆波兰式

 

https://www.cnblogs.com/chenying99/p/3675876.html