面试手写题

01 数组去重

• 方法一：使用第三方插件，如 underscore
• 方法二：ES6 set（集合）方法

var arr = [2,4,5,2,4,7,9,1,9,500];
function getUniqueArray() {
// 1.使用Array.form() 将set转化为数组
var result = Array.from(new Set(arr));
// 2.使用展开运算符 将set转化为数组
var result = [... new Set(arr)];
}

• 方法三 使用数组的forEach()遍历，indexOf()查找

var result = [];
arr.forEach(item => {
	if(result.indexOf(item) === -1) {
	result.push(item)
	}
})

• 方法四 ES6 filter和indexOf()特性

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

• 方法五 ES6 reduce()

// 特点：reduce循环的是上一次循环的结果
var result = arr.reduce((pre,item) = {
return pre.includes(item) ? pre : [...pre, item]
},[]);

• 方法六 利用对象key值唯一的特点

var result = {};
// 把数组每一项取出来作为对象的key值
arr.forEach((item,index) => {
result[arr[index]] = "s";
});
// 将key值取出 并利用 ~~ 取整方法将字符串变为数字
result = Object.keys(result).map(item => ~~ item);

• 方法七 原始的循环遍历：两次for循环

var result = [];
var flag;
for(let i = 0; i < arr.length; i++) {
	flag = false;
	for(let j = i + 1; j < arr.length; j++) {
		flag = false;
		// 如果本次遍历的值和上一次遍历的相等，则舍弃
		if(arr[i] === arr[j]) {
		flag = true;
		};	
	};
	// 如果不一样则放入数组
	if(!flag) {
	result.push(arr[i]);
	}
}

• 方法八 利用数组排序

var result = [];
var temp = arr.sort();
// 判断相邻两个数值是否一样
for(let i = 0; i < temp.length; i ++) {
	if(temp[i] !== temp[i+1]) {
		result.push(temp[i])
	}
}

02 数组降维

• 方法一 数组字符串化

let arr = [[123456],[333],789];
arr += "",
arr.split(",");
console.log(arr)
// ['123456', '333', '789']

• 方法二 递归

// 定义一个降维函数，使用递归的方法
function demo(arr) {
	let newArr = [];
	for (let i = 0; i < arr.length; i++) {
		// 如果遍历到的仍然是一个数组，则调用递归函数将其扁平化，并push到 newArr
		if(Array.isArray(arr[i])) {
			newArr.push.apply(newArr,demo(arr[i]));
		} else {
		// 否则就直接push
			newArr.push(arr[i])
		};	
	};
	// 不要忘记返回结果
	return newArr;
}

let arr = [[123456],[333],789];
console.log(demo(arr))

// [123456, 333, 789]

• 方法三 利用concat

let arr = [[123456],[333],789];
let result = [];
for(let i = 0; i < arr.length; i ++) {
	if(arr[i].constructor == Array) {
		// 则使用concat方法拼接数组
		// 给result重新赋值一份，因为concat返回的是新的数组，并未改变原数组的值
		result = result.concat(arr[i])
	} else {
	// 则正常push
		result.push(arr[i])
	};
};
console.log(result)
 
//  [123456, 333, 789]

• 方法四 利用扩展运算符

// 扩展运算符相当于将数组拆分成最小单位
let arr = [[123456],[333],789];
let result = [];
result = [].concat(...arr);
console.log(result);

// [123456, 333, 789]

• 方法五 利用apply

// apply会把数组拆分成一个个单独的数组，依次传递给concat方法
let arr = [[123456],[333],789];
let result = [];
result = Array.prototype.concat.apply(result,arr);
console.log(result);

// [123456, 333, 789]

• 方法六 Array.prototype.flat()

// flat()方法会按照一个可指定的深度递归遍历数组，
// 并将所有的元素与遍历到的子数组中的元素合并为一个新数组返回。
let arr = [[123456],[333],789];
console.log(arr.flat());

// [123456, 333, 789]

• 方法七：使用stack无限反嵌套多层嵌套数组

let arr = [1,2,3,[1,2,3,4,[2,3,4]]];
function flatten(input) {
	const stack = [...input];
	const res = [];
	while (stack.length) {
		// 使用 pop 从 stack 中取出并移除值
		const next = stack.pop();
		//如果是数组
		if(Array.isArray(next)) {
			// 使用 push 送回内层数组中的元素
			// 不会改动原始输入 original input
			stack.push(...next);
		} else {
			res.push(next);
		}
	};
	// 使用 reverse 恢复原数组的顺序
	return res.reverse()
}
console.log(flatten(arr))

// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]

• 方法八：使用 reduce、concat 和递归无限反嵌套多层嵌套数组

let arr = [1,2,3,[1,2,3,4,[2,3,4]]];
function flattenDeep(arr) {
	return arr.reduce((pre,val) => 
	Array.isArray(val) ? pre.concat(flattenDeep(val)) : pre.concat(val),[])
};
console.log(flattenDeep(arr));

// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]

03 数组排序

• 冒泡排序

 const arr = [911,520,888,666,555,2323];
 function bubbleSort(arr) {
 	let temp;
 	// 两两比较，比较次数为长度减一
 	for(let i = 0; i < arr.length - 1; i ++) {
 		for(let j = 0; j < arr.length -1 -i; j++) {
	 		if(arr[j] > arr[j+1]) {
		 		temp = arr[j];
		 		arr[j] = arr[j+1];
		 		arr[j+1] = temp;
	 		}
 		}
 	}
 	return arr;
 }
 console.log(bubbleSort(arr))
 
 // [520, 555, 666, 888, 911, 2323]