前端简单几个算法

• 数组去重(数据)

// 单数据数组去重
// 方法一: 
let nums = [1, 2, 3, 4,5, 6,9 ,7 , 7, 8, 8]
let newNums1 = [...new Set(nums)]
console.log(newNums1);

// 方法二:要开辟重复的空间. 
function uniqueNums3(nums){
    
    
    if(!Array.isArray(nums)) return
    let result = []
    for(let i =0; i< nums.length; i++) {
    
    
        if(result.indexOf(nums[i])<0){
    
    
            result.push(nums[i])
        }
    }
    return result
}
const res3 = uniqueNums3(nums)
console.log(res3);

• 还有好多方法, 可以猛戳这里

• 数组去重(对象)

// 数据为对象类型

let arr1 = [
    {
    
    
        name: 'kobe',
        age: 42
    },
    {
    
    
        name: 'james',
        age: 36
    },
    {
    
    
        name: 'kobe',
        age: 42
    },
    {
    
    
        name: 'wade',
        age: 35
    },
    {
    
    
        name: 'curry',
        age: 32
    },
    {
    
    
        name: 'curry',
        age: 32
    }
]

// 方法1:遍历, 开辟新空间, 没有就塞进去, 有就算了
function uniqueArr1(arr){
    
    
    if(!Array.isArray(arr)) return 
    let obj = {
    
    }
    let result = []
    for(let item of arr) {
    
    
        if(!obj[item.name]){
    
    
            result.push(item)
            obj[item.name] = true
        }
    }
    return result
}

const res1 = uniqueArr1(arr1)
console.log(res1);


//    方法2: 使用lodash库
//   使用loadsh的uniqBy
_.uniqBy(arr, 'name');

• 让数组按想要的个数分组.

/**
 * 将数组每spliter个分为一组
 */

 let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
 function splitBySpliter(arr, spliter){
    
    
    if(!Array.isArray(arr)) return 

    let newArr = []
    for(let i=0; i< arr.length;) {
    
    
       newArr.push(arr.slice(i, i+= spliter))
    }
    return newArr
 }

 const res = splitBySpliter(arr, 5)
//  二维数组
 console.log(res);
//  展开, 一维数组
 console.log(...res);
 

// 输出:
//  二维数组
[
  [ 1, 2, 3, 4, 5 ],
  [ 6, 7, 8, 9, 10 ],
  [ 11, 12, 13, 14, 15 ],
  [ 16, 17, 18, 19, 20 ]
]

//  展开, 一维数组
[ 1, 2, 3, 4, 5 ] [ 6, 7, 8, 9, 10 ] [ 11, 12, 13, 14, 15 ] [ 16, 17, 18, 19, 20 ]

• 不借助其他变量, 交换两个数的值

/**
 * 不借助变量交换两个数的值
 */

 function swap(x, y){
    
    
    x = x - y // 5, 2 x = 3
    y = x + y // 3 2 y = 5
    x = y - x // 5 3 x = 2
    return [x, y] 
 }

 const res = swap(1, 2)
 console.log(res);

• 冒泡排序:

    // 冒泡排序: 
    //    时间复杂度: O(n**2)
    //    空间复杂度: O(1), 原地算法

    function bubbleSort(arr) {
    
    
        for(let i = 0; i< arr.length -1; i++) {
    
    
            for(let j = 0; j< arr.length -i -1; j ++){
    
    
                if(arr[j] > arr[j +1]){
    
    
                    // S(arr[j], arr[j+1])
                    let temp;
                    temp = arr[j]
                    arr[j] = arr[j +1]
                    arr[j +1 ] = temp
                }
            }
        }
        return arr;
    }

• 快速排序:

/**
 * 分而治之的方式, 
 *          就是声明两个数组, 给一个provit 
 *          大于这个provit就放左边, 否则放右边. 
 */

let array = [1, 89, 0, 29, 11, 111, 798, 90]
var quickSort = function (arr) {
    
    
    if (arr.length <= 1) return arr

    var pivotIndex = Math.floor(arr.length / 2);
    var pivot = arr.splice(pivotIndex, 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]);
        }
    }

    // Es6之前的中的concat和Es6后的拓展运算符是一样效果, ...rest[...arguments]
    // return quickSort(left).concat([pivot], quickSort(right));
    return [...quickSort(left), pivot, ...quickSort(right)]
}

console.log(quickSort(array));