[21届]web前端开发实习生岗位面试准备----算法

一、排序问题

1.1 冒泡

// 递增排序
function bubbleSort(arr){	
	for(let i=0; i<arr.length-1; i++){
		for(let j=i+1; j<arr.length; j++){
			if(arr[i] > arr[j]){
				let temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp; 
			}
		}
	}
	return arr;
}

1.2 快排

// 1
function quickSort1(arr){
	if (arr.length <= 1) {
		return arr;
	}

	let leftArr = [];
	let rightArr = [];
	let q = arr[0];

	for (let i = 0; i < arr.length; i++) {
		if (arr[i] < q) {
			leftArr.push(arr[i])
		}else if (arr[i] > q) {
			rightArr.push(arr[i])
		}
	}

	return quickSort(leftArr).concat([q], quickSort(rightArr));
}

// 2
// @param left 子数组左端点下标
// @param right 子数组右端点下标
function quickSort2(arr, left, right){
	if(left < right){
		let i = left;
		let j = right;
		let x = arr[i];
		while(i < j){
			while( i<j && arr[j]>x ){
				j--;
			}
			
			if(i < j){  // 这里用i++，被换过来的必然比x小，赋值后直接让i自加，不用再比较，可以提高效率
				arr[i++] = arr[j];
			}

			while( i<j && arr[j]<x ){
				i++;
			}

			if(i < j){  // 这里用j--，被换过来的必然比x大，赋值后直接让j自减，不用再比较，可以提高效率
				arr[j--] = arr[i];
			}

		}
		arr[i] = x;

		quickSort2(arr, left, i-1);
		quickSort2(arr, i+1, right);

	}
}

1.3 归并

// @param temp 一个和array同大小的数组，避免递归中重复申请空间
// 执行时 mergeSort(array, 0, array.length, array)
function mergeSort(arr, left, right){
	if(left < right){
		let mid = left + parseInt((right - left) / 2);
		mergeSort(arr, left, mid);
		mergeSort(arr, mid, right);
		merge(arr, left, mid, right);  //将两个有序子数组进行合并
	}
}
function merge(arr, left, mid, right){
	let i = left;
	let j = mid + 1;
	let temp = [];
	let t = 0;  // 临时数组指针

	// 小的元素放进temp数组中
	while(i<=mid && j<=right){
		if(arr[i] <= arr[j]){
			temp[t++] = arr[i++];
		}else{
			temp[t++] = arr[j++];
		}
	}

	// 循环放完后如果子数组还有元素就全部放进去
	while(i <= mid){
		temp[t++] = arr[i++];
	}
	while(j <= right){
		temp[t++] = arr[j++];
	}

	// 将temp拷贝到array中
	t = 0;
	while(left <= right){
		arr[left++] = temp[t++];
	}

}

二、 字符串操作

2.1 翻转字符串

1. 反向遍历

// 1 反向遍历
function reverseString1(str){
	let temp = "";
	for(let i=str.length-1; i>=0; i--){
		temp += str[i];
	}
	return temp;
}

2. 使用数组操作

// 2 使用数组操作
function reverseString2(str){
	let arr = str.split("");
	let i = 0;
	let j = arr.length - 1;
	while(i < j){
		temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
		i++;
		j--;
	}
	return arr.join("");
}

2.2 生成指定长度的随机字符串

function ramdomString(n){
	let str = "abcdefghijklmnopqrstuvwxyz0123456789";
	let temp = "";
	for(let i=0; i<n; i++){
		temp += str.charAt(Math.round(Math.random() * str.length));
	}
	return temp;
}

2.3 判断回文字符串

1. 调用库

function checkPalindrom1(str) {  
    return str == str.split('').reverse().join('');
}

2. 手写

function checkPalindrom2(str){
	let re = /[\W_]/g; // \W匹配任何非单词字符。等价于“[^A-Za-z0-9_]”
	let lowRegStr = str.toLowCase().replace(re, '');  // 将字符串变成小写字符,并去掉除字母数字外的字符
	if(lowRegStr.length === 0){  // 如果字符串lowRegStr的length长度为0时, true
		return true;
	}
	if(lowRegStr[0] != lowRegStr[lowRegStr.length-1]){  // 如果字符串的第一个和最后一个字符不相同，false
		return false;
	}
	return palindrome(lowRegStr.slice(1,lowRegStr.length-1));  // 递归
}

2.4 统计字符串中出现次数最多的字母

JS中判断字符串中出现次数最多的字符及出现的次数

function findMaxFrequencyChar(str){
	if(str.length == 1){
		return str;
	}

	let charObj = {};
	for(let i=0; i<str.length; i++){
		if(!charObj[str.charAt(i)]){
			charObj[str.charAt(i)] = 1;
		}else{
			charObj[str.charAt(i)] += 1;
		}
	}

	let maxChar = '';
	let maxValue = 1;
	for(let k in charObj){
		if(charObj[k] >= maxValue){
			maxChar = k;
			maxValue = charObj[k];
		}
	}

	return maxChar;
}

三、数组操作

3.1 数组去重

1. 比较id

function deduplicationArray11(arr){
	let result = []
	let arrId = []
	for(let item of arr){
		if(arrId.indexOf(item["id"]) == -1){
			arrId.push(item["id"]);
			result.push(item);
		}
	}
	return result;
}

2. foreach直接比较元素

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

3. 使用ES6的Set

function deduplicationArray3(arr){
	let result = Array.from(new Set(arr));  // Set中没有重复元素
	return result; 
}

4. reduce()

function deduplicationArray2(arr){
	let hash = [];
	let result = arr.reduce((item, next) => {
		hash[next.name] ? '' : hash[next.name] = true && item.push(next);
		return item
	}, []);

	return result;
}

3.2 对象数组去重

function deduplicationObjectArray(obj){
	let uniques = [];
	let stringify = {};
	for(let i=0; i<obj.length; i++){
		let keys = Object.keys(obj[i]);
		keys.sort(function(a,b){
			return (Number(a) - Number(b));
		});

		let str = "";
		for(let j=0; j<keys.length; j++){
			str += JSON.stringify(keys[j]);
			str += JSON.stringify(obj[i][keys[j]]);
		}

		if(!stringify.hasOwnProperty(str)){
			uniques.push(obj[i]);
			stringify[str] = true;
		}
	}
	uniques = uniques;
	return uniques;
}

3.3 数组查重

function checkArray(arr){
	
}