原生javscript方法---数组篇(2)

原生javscript方法—数组篇(去重和排序)

去重

var arr = [1, 2, 3, true, true, "a", "b", "c", 4, 3, 0, false, true, false, "c", "b"];

1. 双重for循环+splice删除重复

// 双重for循环+splice删除重复
function arrRemoveRepeat1(arr) {
	for (var i = 0; i < arr.length; i++) {
		for (var j = i + 1; j < arr.length; j++) {
			if (arr[i] === arr[j]) { //两个值相同，需要删除后出现的，就是下标为j的元素
				arr.splice(j, 1);//使用splice方法删除重复的 第一个参数删除的位置，第二个删除的位置
				j--;
			}
		}
	}
	return arr;
}
console.log(arrRemoveRepeat1(arr));//[1, 2, 3, "a", "b", "c", 4, 0]

2. 利用sort()的排序，先排序后去重

function arrRemoveRepeat2(arr) {
	arr = arr.sort();//对数组排序
	console.log(arr);
	var array = [arr[0]];//拿出数组中的第一个
	for (var i = 1; i < arr.length; i++) {//从数组的第二个开始遍历
		if (arr[i] !== arr[i - 1]) {//比较这个元素和前一个是否相同，如果不相同，就把后一个放在新数组内
			array.push(arr[i]);
		}
	}
	return array;
}
console.log(arrRemoveRepeat2(arr));// [0, 1, 2, 3, 4, "a", "b", "c", false, true]   

3. Map数据结构去重

function arrRemoveRepeat3(arr) {
	let map = new Map();
	let array = new Array(); // 数组用于返回结果
	for (let i = 0; i < arr.length; i++) {
		if (map.has(arr[i])) { // 如果有该key值
			map.set(arr[i], true);
		} else {
			map.set(arr[i], false); // 如果没有该key值
			array.push(arr[i]);
		}
	}
	return array;
}
console.log(arrRemoveRepeat3(arr));// [1, 2, 3, true, "a", "b", "c", 4, 0, false]

4. indexOf去重

function arrRemoveRepeat4(arr) {
	let array = [];
	for (let i = 0; i < arr.length; i++) {
		if (array.indexOf(arr[i]) === -1) {
			array.push(arr[i])
		}
	}
	return array;
}
console.log(arrRemoveRepeat4(arr)); // [1, 2, 3, true, "a", "b", "c", 4, 0, false]

5. filter

function arrRemoveRepeat5(arr) {
	let newArr = arr.filter((v, i, arr)=>{
		//当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
		return arr.indexOf(v, 0) === i;
	});
	return newArr;
}
console.log(arrRemoveRepeat5(arr));//[1, 2, 3, true, "a", "b", "c", 4, 0, false]  

6. ES6中的Set

function arrRemoveRepeat6(arr){
	return Array.from(new Set(arr))
}
console.log(arrRemoveRepeat6(arr));// [1, 2, 3, true, "a", "b", "c", 4, 0, false]  

排序

1. sort大法

function arrSort1(arr) {
	arr.sort(function(a, b) {
		return a - b;
	});
	return arr
}
console.log(arrSort1(arr));// [1, 2, 3, 4, 5, 6, 8, 9, 21, 32, 44, 56, 123]

2. 冒泡排序

function arrSort2(arr) {
	for (var i = 0; i < arr.length; i++) { //遍历数据的长度
		for (var j = 0; j < arr.length; j++) { //进行第二轮的循环
			if (arr[j] > arr[j + 1]) { //判断如果第一位数大于第二位数的话
				var temp = arr[j]; //交换位置
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	return arr;
}
console.log(arrSort2(arr));//[1, 2, 3, 4, 5, 6, 8, 9, 21, 32, 44, 56, 123]

3. 选择排序

function arrSort3(arr) {
	//先循环遍历第一遍
	length = arr.length;
	var min; //声明存储最小值的变量
	var temp;
	for (var i = 0; i < length; i++) { //进行第一轮的循环
		min = i; //最小值等于循环到的 i
		for (var j = i; j < length; j++) { //进行第二遍的循环
			if (arr[j] < arr[min]) { //当arr中 j 小于 最小值时 --找到最小的数
				min = j; //就把 j当做是最小的数
			}
		}
		temp = arr[i]; //将temp赋值为arr中的 i
		arr[i] = arr[min]; //将他们交换位置
		arr[min] = temp; //将他们交换位置
	}
	return arr; //将arr返回
}
console.log(arrSort3(arr));// [1, 2, 3, 4, 5, 6, 8, 9, 21, 32, 44, 56, 123]

4. 插入排序

function arrSort4(arr) {
	var length = arr.length;
	var str;
	for (var i = 0; i < length; i++) {
		str = arr[i]; //存储i的值
		for (var j = i; j > 0 && str < arr[j - 1]; j--) {
			// 当前值和之前的每个值进行比较，发现有比当前值小的值就进行重新赋值
			arr[j] = arr[j - 1];
			arr[j - 1] = str;
		}
	}
	return arr;
}
console.log(arrSort4(arr));// [1, 2, 3, 4, 5, 6, 8, 9, 21, 32, 44, 56, 123]