数组去重解析

var arr = [1,4,12,4,5,125,4512,4,4]

Set构造函数

通过new Set() 生成一个类数组，并没有重复的值

let [...result] = new Set(arr) 
// [ 1, 4, 12, 5, 125, 4512 ]

或者可以使用Array.from()，可以把类数组转换成数组结合使用

let result = Array.from(new Set(arr)) 
// [ 1, 4, 12, 5, 125, 4512 ]

Array.indexOf()

Array.indexOf() 返回数组中某个指定元素第一次出现的位置，没有找到指定元素则返回-1

var result = arr.filter((item,index) => {
    return arr.indexOf(item) === index
})

filter函数会返回当前循环的这一项的判断结果,为true则保留这一项, 反之舍弃这一项，在这里第一次出现的4在索引1的位置，并记录下来 ; 最后两个4的索引不等于第一次记录4的索引位置，所以返回 false 并不会被保留
另一种思路或者利用indexOf没找到指定元素返回-1这一特性,把这心不重复的元素push到新数组中

let newArr = []
let result =  arr.forEach(item => {
    if(newArr.indexOf(item) === -1) {
        newArr.push(item)
    }
})
console.log(newArr)
// [ 1, 4, 12, 5, 125, 4512 ]

类似indexOf 方法使用js实现去重，定义一个空数组，循环要去重的数组，如果新数组中有当前这一项break，如果没有就push进去

let newArr = []
const isRepeat;
for(let i=0; i<arr.length;i++) {
 isRepeat = false
 for( let j=0; j< newArr.length;j++) {
    if(arr[i] === newArr[j]) {
        isRepeat = true
        break
    }  
 }
 if(!isRepeat) {
    newArr.push(arr[i])
 }
}
console.log(newArr)
[ 1, 4, 12, 5, 125, 4512 ]

Map构造函数

let tmp = new Map()
let result = arr.filter(item => {
    return !tmp.has(item) && tmp.set(item, 1)
})
console.log(result)
// [ 1, 4, 12, 5, 125, 4512 ]

obj特性去重

let arr = [1, 2, 3, 4, 12, 4, 1, 2]

function fn(arr) {
    let obj = {};
    arr.forEach((item) => {
        obj[item] = '';
    })
    return Object.keys(obj)
}
console.log(fn(arr))
// [ '1', '2', '3', '4', '12' ]

冒泡排序

var a = [45,67,23,88,21,6,99];
for(let i=0; i < a.length-1; i++) {
   for(let j=0; j< a.length-1-i; j++) {
       if(a[j] > a[j+1]) {
           var temp = a[j]
           a[j] = a[j + 1]
           a[j+1] = temp
       }
   }
}
console.log(a) 
// [ 6, 21, 23, 45, 67, 88, 99 ]

相邻两个比较，i项大于i+1项互换位置，循环a.length -1 轮把其中最大一项放到对尾

选择排序

var a = [45,67,23,88,21,6,99];
let min; // 最小值
let pos; // 最小值下标
for(let i=0;i<a.length;i++) {
    min = a[i]
    pos = i
    for(let j=i+1;j<a.length;j++) {
        if(a[j] < min) {
            min = a[j]
            pos = j
        }
    }
    var temp = a[i]
    a[i] = min
    a[pos] = temp
}
console.log(a)
// [ 6, 21, 23, 45, 67, 88, 99 ]

假定最小值min 和最小值的索引默认为第一项，

第二个循环遍历数组中除i项外, 发现有比min的元素小，立即重新对min赋值，第二层循环结束。

在第一层循环中，把当前这一项备份，为了调换位置使用 var temp = a[i]

当前这一项和min调换位置 a[i] = min a[pos] = temp

插入排序

var a=[45,67,23,88,21,6,99];
for(let i=0;i<a.length;i++) {
    for(let j=i;j>0 && a[j] < a[j-1];j--) {
        var temp = a[j]
        a[j] = a[j-1]
        a[j-1] = temp
    }
}
console.log(a)
// [ 6, 21, 23, 45, 67, 88, 99 ]

当前这一项元素和它的前一项进行比较

如果当前的值小于他的前一项那么调换位置, j--会使当前位置向前走一位，直到找到比他小的交换位置后，如果j < 0后跳出循环。最小值会移到数组第一项。

排序算法——插入排序 https://blog.csdn.net/xiaoping0915/article/details/72949784