一些简单的算法

冒泡排序,比如你有五个数  3 4 2 1 0

 

       其原理就是用没个数和 其他数进行比较 下面我们来书写每一轮的数值

       第一轮:

                  3 < 4 > 2       得出队列 2 4 3 1 0   

                  2 < 1  < 0      得出队列 1 4 3 2 0     得出队列   0 4 3 2 1

       第二轮 

                  4 > 3             得出队列 0 3 4 2 1  

                  3 > 2 > 1       得出队列 0 2 4 3 1     得出队列   0 1 4 3 2

       第三轮

                  4 > 3             得出队列 0 1 3 4 2

                  3 > 2             得出队列 0 1 2 4 3

      第四轮

                  4 > 3             得出队列 0 1 2 3 4

      实现代码

let arr = [3,4,2,1,0];
for(let i = 0;arr[i]!=undefined;i++){
    for(let j = i;arr[j]!=undefined;j++){
        if(arr[i] > arr[j]){
            let jh = arr[i];
            let arr[i] = arr[j];
            let arr[j] = jh;
        }
    }
}
console.log(arr);  //[0,1,2,3,4]

已上代码大大消耗了 cpu的性能

列入我们 有几十万个数  那电脑就可能要卡顿个几秒了

接下来我们聊聊 高性能的快速排序9 6 3 7 5 2 1 0 8 4做例子

首先找个基准  找谁为基准都可以 然后和当前所有数列进行对比

首先我们要先定义两个空数组

let arr = [9,6,3,7,5,2,1,0,8,4];
function Sort(arr){
    let left = [];
    let right = [];
}
Sort(arr);

 接下来我们冲数列中 找一个基准 并把他冲数组中移除

 这里说到的基准 其实就是 一个参照数

let arr = [9,6,3,7,5,2,1,0,8,4];
function Sort(arr){
    let left = [];
    let right = [];
    let standard = Math.floor(arr.splice(arr.length / 2,1)); //基准
}
Sort(arr);

  接下来遍历数列  将大于基准值的丢进 left  小于基准值的丢进 right

let arr = [9,6,3,7,5,2,1,0,8,4];
function Sort(arr){
    let left = [];
    let right = [];
    let standard = Math.floor(arr.splice(arr.length / 2,1)); //基准
    for(let i = 0;arr[i]!=undefined;i++){
        if(arr[i] > standard){
            right.push(arr[i]);
        }else{
            left.push(arr[i]);
        }
    }
}
Sort(arr);

  最后我们还需要递归该数列    既然说了是递归,就要加一个出口条件 否则会出现

  too much recursion

let arr = [9,6,3,7,5,2,1,0,8,4];
function Sort(arr){
    if(arr.length <= 0)return arr;    //出口
    let left = [];
    let right = [];
    let standard = Math.floor(arr.splice(arr.length / 2,1)); //基准
    for(let i = 0;arr[i]!=undefined;i++){
        if(arr[i] > standard){
            right.push(arr[i]);
        }else{
            left.push(arr[i]);
        }
    }
    return Sort(left).concat(standard,Sort(right));   //递归
}
Sort(arr);

  还有就是常用的斐波那契数列

  斐波那契数列就是前两个数 的合等于第三个数

  首先 先创建一个空数组

  生成指定长度斐波那契数

let arr = [];
function Fibonacci(index){
    
}
let item = Fibonacci(10);    //比如我们创建一个长度为10的斐波那契数列
console.log(item);

 首先判断如果前两个数 = undefined 那么插入值为1否则插入计算结果

let arr = [];
function Fibonacci(index){
    let value = (arr[arr.length - 1] + arr[arr.length - 2]);
    if(isNaN(value) == true){
        arr.push(1);
    }else{
        arr.push(value);
    }
    if(--index <= 0)return arr;//定义递归的出口
    return Fibonacci(index);
}
let item = Fibonacci(10);    //比如我们创建一个长度为10的斐波那契数列
console.log(item);    

  简单的去重算法

        其实去重的原理就是  将不同的值丢进一个空数组中

        上面说到空数组 因此要创建两个数组 一个记录下标的值

        

function uniq(arr,arr1 = [],index = 0){
    
}
let arr = [2,2,9,5,3,9,5,2,4,3,3,1];
$item = uniq(arr);
console.log($item);

        接下来就是判断空数组中是否有改值没有就push进去 值到遍历完arr后 返回arr1

 

      

function uniq(arr,arr1 = [],index = 0){
    if(arr[index] == undefined)return arr1;
    if(arr1.indexOf(arr[index]) == -1){
            arr1.push(arr[index]);
    }
    return uniq(arr,arr1,++index);
}
let arr = [2,2,9,5,3,9,5,2,4,3,3,1];
$item = uniq(arr);
console.log($item);

简单的会文算法

在该例子中我会分别检测asdsa  和 asdddsa  还有 aab 是否是回文 由于回文比较简单我就不做过多解释了

原理其实就是将值反转一下判断是否和原值相等 此处方法较多我子介绍那种在没有js时类似于c语言的算法

function isKaibun(str,str1 = "",index = str.length - 1){
    if(index < 0)return str === str1;
        str1 += str[index];
        return isKaibun(str,str1,--index);
}
console.log(isKaibun("asdsa"));  //true
console.log(isKaibun("asdddsa"));  //true
console.log(isKaibun("aab"));  //false