每日JavaScript - 11 十种数组去重方法，寻找最长子串的长度

107 阅读 0 评论 71 点赞

我是靠谱客的博主直率小海豚，最近开发中收集的这篇文章主要介绍每日JavaScript - 11 十种数组去重方法，寻找最长子串的长度，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

csd题目1
给定一个字符串，找出不含有重复字符的最长子串长度
如 ‘abcabcbb’ 输出3，子串为abc
‘pwwkew’ 输出3，子串为wke
‘bbbbbb’ 输出1，字串为b

感觉自己以前做过这题，也是非常基础的题目

let test1 = 'abcabcbb'
let test2 = 'pwwkew'
let test3 = 'bbbbbbb'
function findLen(str) {
let res = 0
let temp = []
let len = str.length
for (let i = 0; i < len; i++) {
if (!temp.includes(str[i])) {
temp.push(str[i])
} else {
if (temp.length > res) {
res = temp.length
}
temp.length = 0
temp.push(str[i])
}
}
return res
}
console.log(findLen(test1))
console.log(findLen(test2))
console.log(findLen(test3))

掘金大佬版本

function findLen(s) {
let map = new Map()
let start = -1,
maxLen = 0
arr = s.split("")
arr.forEach((element, index, arr) => {
if (map.has(element)) {
start = Math.max(map.get(element), start)
}
map.set(element, index)
maxLen = Math.max(index-start, maxLen)
})
return maxLen
}

我觉得我的写法比较简单易懂吧，大佬用了Map，这个不太懂。
题目2
再贴一个黄老师在沸点提出的问题吧。

console.log(1 == [1]);
// true
console.log('1' == [1]);
// true

== 会默认进行隐式转换，[1]先调用valueof返回自身，再调用toString返回’1’，所以两个console.log都输出true。
题目3
创建一个6x6的二维数组，元素全为1

function twoD(num) {
let i = num
let res = new Array(num)
while (i) {
res[i - 1] = new Array(num).fill(1)
i --
}
return res
}

二维数组可以如此简单创建

var A=new Array(10);
for(var i=0;i<10;i++){
A[i]=new Array(10);
}

题目4
给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

function findMost(arr) {
arr.sort()
// return arr[Math.floor(arr.length / 2)]
// 右移一位
return arr[arr.length >> 1]
}
let test = [2,2,1,1,1,2,2]
console.log(findMost(test))

题目5、
尽可能的写出多的数组去重方法
(这只能用来去除基本类型，对于像对象引用类型要这门写个比较函数来去重，因为对象可能多层嵌套，所以不好比较，未来我写写这个函数吧)

方法1：使用sort()，对比相邻两个元素，相同就去除。

function unique(arr) {
let res = []
let len = arr.length
let i = len
arr.sort()
while (i) {
if (arr[len - i] !== arr[len - i -1]) {
res.push(arr[len - i])
}
i --
}
return res
}
let test = [2,2,1,1,1,2,2]
console.log(unique(test))

方法2：使用对象的键是唯一的特性，进行去重。

obj[arr[i]] = 0

注意这个方法有个小坑，不能赋给0，因为if (!obj[arr[i]]) 会隐式转换，使得判断永远为true

function unique(arr) {
let res = []
let obj = {}
let len = arr.length
let i = 0
while (i < len) {
if (!obj[arr[i]]) {
//
不能标记为0
obj[arr[i]] = 1
res.push(arr[i])
}
i ++
}
return res
}
console.log(unique(test))

方法3：使用ES6中的set进行去重

// 就是这么短
let unique = (arr) => [...new Set(arr)]

方法4：创建新的数组使用includes判断是否去重

function unique(arr) {
let res = []
let len = arr.length
let i = 0
while(i < len){
if (!res.includes(arr[i])) {
res.push(arr[i])
}
i ++
}
return res
}
console.log(unique(test))

方法5：利用filter 注意self代指数组本身

const distinct = arr => arr.filter( (element, index, self) => {
return self.indexOf( element ) === index;
});
let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
distinct(arr); // [1, 2, 3, 5, 4]

方法6：利用indexOf和 lastIndexOf，在原数组更改。

function unique(arr) {
for (let i = 0; i < arr.length >> 1; i++) {
console.log(arr.length)
if (arr.indexOf(arr[i]) !== arr.lastIndexOf(arr[i])) {
arr.splice(arr.lastIndexOf(arr[i]), 1)
// 遇到重复元素后，删除后面的元素后再检查前面是否有相同的元素
i--
}
}
return arr
}
let array = [11,22,33,44,55,22,33,54]
console.log(unique(array))

方法7：使用双循环

function uniqueArr(arr) {
for (let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i] === arr[j]) {
arr.splice(j, 1)
j--
}
}
}
return arr
}

方法8 使用hasOwnProperty和typeof

function uniqueArray(arr) {
let obj = {}
return arr.filter((item, index, arr) =>
obj.hasOwnProperty(`${typeof item} ${item}`) ? false : (obj[`${typeof item} ${item}`] = 1)
)
}
let testArr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}]
console.log(uniqueArray(testArr))

方法9：使用Map

function arrayNonRepeatfy(arr) {
let map = new Map()
let array = []
for (let i = 0; i < arr.length; i++) {
if (map.has(arr[i])) {
map.set(arr[i], true)
} else {
map.set(arr[i], false)
array.push(arr[i])
}
}
return array
}

方法10：使用reduce

const uni = arr => arr.reduce((acc, cur) => acc.includes(cur) ? acc : [...acc, cur], [])

let arr = [1, 2, 3, 1, 1, 2, 3, 3, 4, 3, 4, 5]
let result = arr.reduce((prev, item, index, arr) => {
!prev.includes(item) && prev.push(item);
return prev
}, [])
console.log(result);
//[1, 2, 3, 4, 5]

&& 操作符会检查第一个参数是否为true，当第一个操作数为false时，不会对第二个操作数进行求职。相反，如果第一个操作数为true时，则会对第二个操作数进行求值。

希望这是我最后一次写数组去重。