基础算法

1. 字符串

相关api：
1. String.slice(strat,end)  截取字符串，包含左区间，不包含右区间，如果只有一个值则从该值开始到最后一个
2. String.toUpperCase() 将字符串全部大写
3. String.toLowerCase() 将字符串全部小写
4. String.split()   将字符串按规则分隔成数组
5. String.indexOf() 查找某个字符串是否存在，存在返回索引值，不存在返回-1
6. String.search(reg)   功能与indexOf一致，支持正则查找字符串  
7. String.match()   即支持正则也可以字符串 它返回的不是索引值而是数组 ["f", index:2,input:"adfcs"]
8. String[0]        读取字符串的索引值，读取索引为0的字符串，类似数组
​
3. Array.splice(start,count,item)   start 开始包含，count 数量 item替换值
4. Array.push() 将数据添加到数组中
5. Array.map()  数组循环，需要return，会返回一个新数组
6. Array.join() 将数组按照join规则拼接成字符串
7. Array.reverse()  将数组中元素颠倒，并返回该数组
​
1. 退出for循环：break(中止循环)、continue(中止本次循环，i++)、return(中止循环); 函数中需要return返回值
2. forEach 循环使用return是没有用的，只会退出当前值循环，不会退出本次总循环，还会继续i++
​

1.1 首字母大写

案例一
// 将给定字符串首个字母大写     'like practice vue'
function test(str){
    return str.slice(0,1).toUpperCase()+str.slice(1).toLowerCase()
}
console.log(test('tokil like practice vue')) // Tokil like practice vue
​
案例二
// 将给定字符串的每个字母的首字母大写    
function test(str){
    let arr = str.split(' ')
    let result = arr.map(item => {
        return item.slice(0,1).toUpperCase()+item.slice(1).toLowerCase()
    }).join(' ')
    return result
}
console.log(test('tokil like practice at vue')) //Tokil Like Practice At Vue

1.2 反转单词

// 将给定字符串的每个单词进行反转  'tokil like practice vue'
function test(str){
    let arr = str.split(' ')
    let result = arr.map(item => {
        let res = item.split('').reverse().join('')
        return res
        // return res.slice(0,1).toUpperCase()+res.slice(1).toLowerCase()
    }).join(' ')
    return result
}
console.log(test('tokil like practice vue'))

2. 数组

2.1 手机号

/* 目标
手机号 2[abc] 3[def]  4[ghi]
输入:'23'
输出:['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf'] */
function test(str){
    let rule = ['', '', 'abc', 'def', 'ghi', 'jkl', 'mno', 'pqrs', 'tuv', 'wxyz']
    let num = str.split('')
    let code = []
    num.forEach(item => {
        if(num.length){
            code.push(rule[item])
        }
    })
    let comb = (arr) => {
        for(let i=0;i<arr[0].length;i++){
            for(let j=0;j<arr[1].length;j++){
                let tmp.push(`${arr[0][i]}${arr[1][j]}`)
            }
        }
        arr.splice(0,2,tmp)
        if(arr.length>1){
            comb(arr)
        }else{
            return tmp
        }
        return arr[0]
    }
    return comb(code)
}
console.log(test('23')) // ['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']

2.2 卡牌分组

// [1,1,2,2,2,2]     [1,1][2,2][2,2]       true
// [1,1,1,2,2,3,3,3] [1,1,1][2,2][3,3,3]   false    分成一样的个数
function test(arr){
    arr.sort((a,b) => a-b)
    let result = []
    let res = true
    let min = Number.MAX_SAFE_INTEGER
    for(let i=0,tmp=[];i<arr.length;i++){
        tmp.push(arr[i])
        // length+1：因为需要拿最后一个值的后值(undefine)去做比较
        for(let j=i+1;j<arr.length+1;j++){
            if(arr[i]===arr[j]){
                tmp.push(arr[j])
            }else{
                if(min>tmp.length){
                    min = tmp.length
                }
                result.push([].concat(tmp))
                tmp.length = 0
                // break之后会执行i++,需要减1才会是等于j
                i = j - 1
                break
            }
        }
    }
    // 循环判断 数组长度能否整除最小长度，能那么符合
    result.forEach(item => {
        if(item.length % min === 1){
            res = false
            return false
        }
    })
    return res
}
console.log(test([1,1,2,2,2,2]))

2.3 花坛种花

/*  
    种花的1需要左右都有0才能种植,两边界除外,能种的数量是否大于输入k值
    [0,1,0,0,0,1,1,1,1,1,0,0,1,0,1,1,0,0,0]
    [0,0,0,0,0,1,1,1,1,1,0,0,1,0,1,1,0,0,0]
*/
function test(arr,k){
    let num = 0
    for(let i=0; i<arr.length;i++){
        if(arr[i] === 0){
            if(i===0 && arr[1] ===0){
                num++
                i++
            }else if(arr[i-1]===0 && arr[i+1] ===undefined){
                num++
                i++
            }else if(arr[i-1] === 0 && arr[i+1] === 0){
                num++
                i++
            }
        }
    }
    if(num>k){
        return true
    }else{
        return false
    }
}
console.log(test([0,1,0,0,0,1,1,1,1,1,0,0,1,0,1,1,0,0,0])) // 2

3. 数组排序

3.1 冒泡排序

// 两两比较，先得到最大值放右边，从大到小
function test(arr){
    for(let i=arr.length-1;i>0;i--){
        for(let j=0;j<i;j++){
            if(arr[j]>arr[j+1]){
                [arr[j],arr[j+1]] = [arr[j+1],arr[j]]
            }
        }
    }
    return arr
}
console.log(test([6,9,3,2,5,1]))

3.2 选择排序

// 每个值互相比较，最小的放左边，从小到大
function test(arr){
    for(let i=0;i<arr.length;i++){
        for(let j=i+1;j<arr.length;j++){
            if(arr[i]>arr[j]){
                [arr[i],arr[j]] = [arr[j],arr[i]]
            }
        }
    }
    return arr
}
console.log(test([9,4,6,2,5,1]))

3.3 最大间距

// 循环之后，找出两值之间最大差 [1,16,26,36]
function test(arr){
    arr.sort((a,b) => a-b)
    let max = Number.MIN_SAFE_INTEGER
    for(let i=0;i<arr.length-1;i++){
        if(arr[i+1]-arr[i]>max){
            max = arr[i+1]-arr[i]
        }
    }
    return max
}

// 冒泡中求差提升性能
function test(arr){
    let max = Number.MIN_SAFE_INTEGER
    for(let i=arr.length-1;i>0;i--){
        for(let j=0;j<i;j++){
            if(arr[j]>arr[j+1]){
                [arr[j],arr[j+1]] = [arr[j+1],arr[j]]
            }
        }
        //从第二个值开始，就可以开始比较差值
        if(i<arr.length-1){
            if(max<arr[i+1]-arr[i]){
                max = arr[i+1]-arr[i]
            }
        }
    }
    // for循环中不需要return，函数里面才需要return
    return Math.max(max,arr[1]-arr[0])
}
console.log(test([1,16,26,36]))

3.4 奇偶排序

/*
    将数组中的一半奇数一半偶数，根据索引下标去对应排序,索引是偶则对应偶数，索引奇数则对应奇数
	[4,9,7,2] ==> [2,7,4,9]
*/
function test(arr){
    arr.sort((a,b) => a-b)
    let odd=0
    let even=1
    let res=[] 
    for(let i=0;i<arr.length;i++){
        if(arr[i] % 2 ===0){
            res[odd]=arr[i]
            odd+=2
        }else if(arr[i] % 2 ===1){
            res[even]=arr[i]
            even+=2
        }
    }
    return res
}
console.log(test([2,4,7,9]))

3.5 数组中第k个最大元素

// 查找数组中第4大元素	[1,5,6,7,9,3,11] =6
function test(arr,k){
    // return arr.sort((a,b) => a-b)[k-1]
    let result
    for(let i=arr.length-1;i>0;i--){
        for(let j=0;j<i;j++){
            if(arr[j]>arr[j+1]){
                [arr[j],arr[j+1]] = [arr[j+1],arr[j]]
            }
        }
        // arr.length-1-i = k-1	
        if(arr.length-i==k){
            result = arr[i]
            return result
        }
    }
}
console.log(test([1,5,6,7,9,3,11],4))

3.6 缺失的第一个正整数

/*给定一个未排序的整数数组，找出没有出现的最小正整数   [1,3,4,5]  2*/
function test(arr){
    arr.sort((a,b) => a-b)
    let num = 1
    for(let i=0;i<arr.length;i++){
        if(arr[i]>0){
            if(arr[i]===num){
            	num++
            }else{
                return num
            }
        }
    }
    return num
}
console.log(test([0,2,3,4]))