算法学习积累

一、数组格式转换
//将数组
let beforeData = [
	{name: '1',type: 0},
	{name: '2',type: 0},
	{name: '3',type: 2},
	{name: '4',type: 2},
	{name: '5',type: 3},
	{name: '6',type: 3}
]
//转换为数组
let z = [
	{type: 0,value: [{name: '1',type: 0}, {name: '2',type: 0}]},
	{type: 2,value: [{name: '3',type: 2}, {name: '4',type: 2}]},
	{type: 3,value: [{name: '5',type: 3}, {name: '6',type: 3}]},
]
解法1、
let tempArr = [];
let afterData = [];
for (let i = 0; i < beforeData.length; i++) {
//indexOf是返回某个指定的字符串值在字符串中首次出现的位置,如果要检索的字符串值没有出现,则该方法返回 -1。
	if (tempArr.indexOf(beforeData[i].type) === -1) {
		afterData.push({
			type: beforeData[i].type,
			value: [beforeData[i]]
		});
		tempArr.push(beforeData[i].type);
	} else {
		for (let j = 0; j < afterData.length; j++) {
			if (afterData[j].type == beforeData[i].type) {
				afterData[j].value.push(beforeData[i]);
				break;
			}
		}
	}
}
console.log(afterData)
解法2、
let afterData=Array.from(new Set(a.map((val)=>{return val.type}))).map(item=>{
	return{
		type:item,
		value:a.filter((e)=>{
			if(item===e.type){
				return e
			}
		})
	}
})
//Array.from(new Set(a.map((val)=>{return val.type})))     //[0,2,3],type值唯一的数组
//1、Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组。
//2、Set是es6新增的数据结构,似于数组,但它的一大特性就是所有元素都是唯一的,没有重复的值,我们一般称为集合。
//3、filter用于把Array的某些元素过滤掉,然后返回剩下的元素。和map()类似,Array的filter()也接收一个函数。
//和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是true还是false决定保留还是丢弃该元素。
console.log(afterData)

二、

给定一个只包括'(',')','{','}','[',']'的字符串,判断字符串是否有效
有效字符串需满足:
1.左括号必须用相同类型的右括号闭合.
2.左括号必须以正确的顺序闭合.

实例1:
输入:"()"
输出:true

实例2:
输入:"()[]{}"
输出:true

实例3:
输入:"(]"
输出:false

实例4:
输入:"([)]"
输出:false

实例5:
输入:"{[]}"
输出:true
解法1、
function judge(str) {
	if (str.length % 2 != 0) {
		return false
	}
	let tempArr = []
	let arr = str.split('')
	for (let i = 0; i < arr.length; i++) {
		let lastLetter=tempArr[tempArr.length-1]
		switch (arr[i]) {
			case '(':
				tempArr.push('(');
			break
			case '{':
				tempArr.push('{');
			break
			case '[':
				tempArr.push('[');
			break
			//push()方法可以在数组的末属添加一个或多个元素
			//shift()方法把数组中的第一个元素删除
			//unshift()方法可以在数组的前端添加一个或多个元素
			//pop()方法把数组中的最后一个元素删除
			case ')':
				if(lastLetter==='('){
					tempArr.pop();
				}
			break
			case '}':
				if(lastLetter==='{'){
					tempArr.pop();
				}
			break
			case ']':
				if(lastLetter==='['){
					tempArr.pop();
				}
			break
		}
	}
	return tempArr.length==0
}
console.log(judge('([)'))    //false
console.log(judge('([])'))   //true
解法2、
function judge(str) {
	for (let i = 0; i < str.split('').length / 2 + 1; i++) {
		if (str.indexOf('{}') != -1) {
			str = str.replace('{}', '')
		}
		if (str.indexOf('()') != -1) {
			str = str.replace('()', '')
		}
		if (str.indexOf('[]') != -1) {
			str = str.replace('[]', '')
		}
	}
	return str == ''
}
console.log(judge('([)'))	//false
console.log(judge('([])'))	//true
解法3、
const isValid = function(s) {
	if (s.length % 2 == 1) return false;
	let stack = [];
	for (let i = 0; i < s.length; i++) {
		const strItem = s[i];
		if (strItem === '{' || strItem === '[' || strItem === '(') {
			stack.push(strItem);
		} else {
  			if (stack.length === 0) return false;
 			const item = stack[stack.length - 1];
			if (item === '{' && strItem === '}' || item === '[' && strItem === ']' || item == '(' &&strItem == ')') {
				stack.pop();
			} else {
 				return false;
			}
		}
	}
	return stack.length === 0;
};
console.log(isValid('{}'));		//true
console.log(isValid('{}[]'));	//true
console.log(isValid('{[}'));	//false
三、插入排序
function Insertion(){
	var arr = [1, 55, 35, 4, 9, 26]
	for(var i=0;i<arr.length;i++){
		for(j=0;j<i;j++){
			if(arr[i]<arr[j]){
				arr.splice(j, 0, arr[i])
				arr.splice(i + 1, 1)
			}
		}
	}
	return arr//[1,4,9,26,35,55]
}
四、反转字符串
解法1、
字符串转数组,反转数组,数组转字符串。
  • split(“”):根据空字符串拆分数组
  • reverse():数组反转元素位置
  • join(“”):数组转回字符串,且不带分隔符
let str = "hello world";
let newStr = str.split("").reverse().join("");
console.log(newStr);
解法2、
定义新的空字符串,遍历str,charAt()是取字符串的一个字符(charAt() 方法可返回指定位置的字符)
var str = "hello";
var strArr = str.split('');
var resultStr = '';
for (var i = strArr.length-1; i >= 0; i--) {
    resultStr += str.charAt(i);
}
console.log(resultStr);
解法3、
unshift() 将新项目添加到数组的开头:
var str = "hello";
var strArr = str.split('');
var result=[];
var resultStr = '';
for (var i = 0, l = strArr.length; i < l; i++) {
    result.unshift(strArr[i]);
}
resultStr=result.join('')
console.log(resultStr); 
五、数组去重
解法1、利用ES6中的 Set 方法去重
Set为ES6新增的一个对象,允许存储任何类型(原始值或引用值)的唯一值
let arr = [1,0,0,2,9,8,3,1];
function unique(arr) {
    return Array.from(new Set(arr))
}
console.log(unique(arr));   // [1,0,2,9,8,3]  
解法2、(…)
拓展运算符(…)内部使用for…of循环
let arr = [1,2,3,3];
let resultarr = [...new Set(arr)]; 
console.log(resultarr); //[1,2,3]
解法3、
function unique(){
	var arr=[1,1,3,5,6]
	var newArr=[]
	for(var i=0;i<arr.length;i++ ){
		for(var j=i+1;j<arr.length;j++){
			if(arr[i]==arr[j]){
				j=++i
			}
		}
		newArr.push(a[i])
	}
	console.log(arr)//[1,3,5,6]
}
解法4、使用双重for循环,再利用数组的splice方法去重
var arr = [1, 5, 6, 0, 7, 3, 0, 5, 9, 5, 5];
function unique(arr) {
	for (var i = 0; i < arr.length; i++) {
		for (var j = i + 1; j < arr.length; j++) {
			if (arr[i] === arr[j]) {
				arr.splice(j, 1);
				j--; // 每删除一个数j的值就减1
			}
		}
	}
	return arr;
}
console.log(unique(arr)); //  1, 5, 6, 0, 7, 3, 9
解法5、利用数组的indexOf方法去重
array.indexOf(item,statt) 返回数组中某个指定的元素的位置,没有则返回-1
var arr = [1, -5, -4, 0, -4, 7, 7, 3];
function unique(arr) {
	var arr1 = []; // 新建一个数组来存放arr中的值
	for (var i = 0; i < arr.length; i++) {
		if (arr1.indexOf(arr[i]) === -1) {
			arr1.push(arr[i]);
		}
	}
	return arr1;
}
console.log(unique(arr)); // 1, -5, -4, 0, 7, 3
解法6、利用数组的sort方法去重(相邻元素对比法)
array.sort( function ) 参数必须是函数,可选,默认升序
var arr = [5, 7, 1, 8, 1, 8, 3, 4, 9, 7];
function unique(arr) {
	arr = arr.sort();
	console.log(arr)//[1, 1, 3, 4, 5, 7, 7, 8, 8, 9]
	var arr1 = [arr[0]];
	for (var i = 1; i < arr.length; i++) {
		if (arr[i] !== arr[i - 1]) {
			arr1.push(arr[i]);
		}
	}
	return arr1;
}
console.log(unique(arr)); //[1, 3, 4, 5, 7, 8, 9]
解法7、利用数组的includes去重
arr.includes(指定元素(必填),指定索引值(可选,默认值为0) ),有值返回true,没有则返回false
var arr = [-1, 0, 8, -3, -1, 5, 5, 7];
function unique(arr) {
	var arr1 = [];
	for (var i = 0; i < arr.length; i++) {
		if (!arr1.includes(arr[i])) { // 检索arr1中是否含有arr中的值
			arr1.push(arr[i]);
		}
	}
	return arr1;
}
console.log(unique(arr)); //  -1, 0, 8, -3, 5, 7
解法8、利用数组的filter方法去重
filter() 方法创建一个新的数组,新数组中的元素是通过检查指定数组中符合条件的所有元素,array.filter(function(currentValue,index,arr), thisValue)
currentValue:当前元素的值(必选参数)、index:当前元素的索引值(可选)、arr:当前元素属于的数组对象(可选)、thisValue:对象作为该执行回调时使用,传递给函数,用作 “this” 的值,默认undefined(可选)
/* 模拟:原始数组:[1,2,8,9,5,8,4,0,4]
       	索引值:0,1,2,3,4,5,6,7,8
      	伪新数组:[1,2,8,9,5,8,4,0,4]
使用indexOf方法找到数组中的元素在元素在中第一次出现的索引值
        索引值:0,1,2,3,4,2,6,7,6
    	返回前后索引值相同的元素:
      	新数组:[1,2,8,9,5,4,0]*/
var arr = [1,2,8,9,5,8,4,0,4];
function unique( arr ){
    // 如果新数组的当前元素的索引值 == 该元素在原始数组中的第一个索引,则返回当前元素
    return arr.filter(function(item,index){
        return arr.indexOf(item,0) === index;
    });
}
console.log(unique(arr));    //  1, 2, 8, 9, 5, 4, 0
解法9、利用ES6中的Map方法去重
/*
创建一个空Map数据结构,遍历需要去重的数组,把数组的每一个元素作为key存到Map中。
由于Map中不会出现相同的key值,所以最终得到的就是去重后的结果。
*/
let arr = [1, 0, 8, 3, -9, 1, 0, -9, 7]
function unique(arr) {
	let map = new Map();
	let arr1 = []
	for (let i = 0; i < arr.length; i++) {
		if (map.has(arr[i])) { // 判断是否存在该key值
			map.set(arr[i], true);//添加新的key-value
		} else {
			map.set(arr[i], false);
			arr1.push(arr[i]);
		}
	}
	return arr1;
}
console.log(unique(arr)); // 1, 0, 8, 3, -9, 7
六、统计字符串字符的出现次数、出现次数最多数、出现次数最少数
//考虑到出现频率最高的字符可能有多个,所以需要一个数组来存储出现频率最高的字符,再通过join方法转成字符串
var str = "hellooworld";
var map = {},
		num = 0,
		maxStr = '',
		resArr = [],
		
		minNum=1,
		minStr='',
		resLowArr=[]
	for (var i = 0; i < str.length; i++) {
		if (map[str[i]]) {
			map[str[i]].sonnum++
		} else {
			map[str[i]] = {
				sonnum: 1
			}
		}
	}
	console.log(map)
	for (var key in map) {
		console.log('字符:' + key + ',出现的次数为:' + map[key].sonnum)
		if (map[key].sonnum > num) {
			resArr = [key]
			num = map[key].sonnum
		} else if (map[key].sonnum == num) {
			resArr.push(key)
			num = map[key].sonnum
		}
	}
	maxStr = resArr.join(',')
	console.log('出现频率最高的字符是:' + maxStr + ',出现次数为:' + num)
	
	for (var key in map) {
		console.log('字符:' + key + ',出现的次数为:' + map[key].sonnum)
		if (map[key].sonnum < minNum) {
			resLowArr = [key]
			minNum = map[key].sonnum
		} else if (map[key].sonnum == minNum) {
			resLowArr.push(key)
			minNum = map[key].sonnum
		}
	}
	minStr = resLowArr.join(',')
	console.log('出现频率最低的字符是:' + minStr + ',出现次数为:' + minNum)
	

在这里插入图片描述

七、正数组的最大差值
解法1、通过循环条件判定找到最大,最小值
var arr=[1,3,4,6,2,8,10];
for(var i=0;i<arr.length;i++){
    var a=arr[0];
    var b=arr[0];
    if(a<arr[i]){
   	 	a=arr[i];
    }else if(b<arr[i]){
    	b=arr[i];
    }
}
console.log(a-b);
解法2、从小到大排序后 最后一个数(最大)减去第一个数(最小)
function c(a,b){
	return a-b;
}
var n=arr.sort(c);
t=n[n.length-1]-n[0];
console.log(t);
解法3、Math方法找出最大值与最小值并相减
function aaa(arr){
	var max=Math.max.apply(null,arr);
    var min=Math.min.apply(null,arr);
    return max-min;
}
console.log(aaa(arr));
八、排序
解法1、sort()方法
var ar1=[2,4,6,8,1,3]
var ar2=[2,16,36,8,56]
// ar1.sort()
// ar2.sort()
// //这个方法值只能排序第一个数  也可以字符串进行排序
// console.log(ar1)//[1,2,3,4,6,8]
// console.log(ar2)//[16, 2, 36, 56, 8]
ar1.sort(function(a,b){
    return a-b //a-b为升序
    return b-a  //b-a为降序
})
ar2.sort(function(a,b){
    return a-b //a-b为升序
    return b-a  //b-a为降序
})
console.log(ar1)//[1,2,3,4,6,8]
console.log(ar2)//[2, 8, 16, 36, 56]
解法2、
冒泡排序(每轮依次比较相邻两个数的大小,后面比前面小则交换)
var b//设置用来调换位置的值
var a=[1,9,33,2,5,34,23,98,14]//冒泡排序
for(var i=0;i<a.length-1;i++){
    for(var j=0;j<a.length-i-1;j++){
        if(a[j]>a[j+1]){
            b=a[j]
            a[j]=a[j+1]
            a[j+1]=b
        }
    }
}
console.log(a)//[1, 2, 5, 9, 14, 23, 33, 34, 98]
解法3、选择排序
通过比较首先选出最小的数放在第一个位置上,然后在其余的数中选出次小数放在第二个位置上,依此类推,直到所有的数成为有序序列。
var arr = [9, 8, 7, 6, 5, 4]; //用选择排序的方法从小到大排列数组元素。
//比较的轮数   
for (var i = 0; i < arr.length - 1; i++) {
	//每轮比较的次数          
	for (var j = i + 1; j < arr.length; j++) {
		if (arr[i] > arr[j]) {
			var tmp = arr[i];
			arr[i] = arr[j];
			arr[j] = tmp;
		}
	}
}
alert(arr); //4,5,6,7,8,9
解法4、快速排序
先从数列中取出一个数作为基准数,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边,再对左右区间重复第二步,直到各区间只有一个数
在这里插入代码片
解法5、二分查找排序
在这里插入代码片
将一个数插入到一组排好序的数组中:
function pushNum(arr,num){
	var index;
	for(var i=0;i<arr.length;i++){
		if(num<arr[i]){
			index=i;
           //找位置 
			break}
	}
	for(var j=arr.length;j>index;j--){
		arr[j]=arr[j-1]//腾位置(右移)
	}
	arr[index]=num;//放
	return arr
}
var arr=[1,3,5,7,9]
pushNum(arr,6)
将数组元素循环右移若干位:
function moveRightArr(arr,n){
	var m=n%arr.length;
	for(var j=0;j<m;j++){
		var temp = arr[arr.length-1]
		for(var i=arr.length-1;i>0;i--){
			arr[i] = arr[i-1]
		}
		arr[0]=temp
	}
	return arr;
}
moveRightArr([1,2,3,4,5],2)//[4,5,1,2,3]
水仙花数:100~999内,abc=a3+b3+c^3;
function sum(){
	var i;
	for(var i=100;i<=999;i++){
		//1、求出每个数位的数字
		var ge = i%10;
		var shi = parseInt(i%100/10);
		var bai = parseInt(i/100);
		//2、立方和进行判断
		if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
			console.log(i+',')
		}
	}
}
sum()//153,370,371,407
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值