技術標籤：簡單演算法

• 陣列去重(資料)

// 單資料陣列去重
// 方法一: 
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));