判断一个字符串是否为回文
利用js数组实现
let str = 'abccba';
let strArr = str.split(''); // 将字符串拆分成数组
// let strArr = Array.prototype.map.call(str, function (x) {
// return x
// }); // 将字符串拆分成数组
let strRe = strArr.reverse().join('');
if (str === strRe) {
console.log('是回文');
} else {
console.log('不是回文);
}
复制代码
利用数组reduceRight()方法
function rsTest(str) {
return str === rs(str);
}
function rs(str) {
let result = '';
Array.prototype.reduceRight.apply(str, [function (pre, current) {
result = pre + current;
return result;
}, '']);
return result;
}
let str = 'abccba';
console.log('====rsTest', rsTest(str));
复制代码
用栈判断
function isTrue(str) {
let odStr = str.split('');
let arr = [];
for (let i = str.length - 1; i < str.length && i > -1; i = i - 1) {
arr.push(str[i]);
}
if (arr.toString().replace(/,/g, '') === odStr.toString().replace(/,/g, '')) {
return true;
} else {
return false;
}
}
console.log('=====d', isTrue('abcba'));
复制代码
去掉数组中重复的值
使用es6的set
function set(arr) {
return [...new Set(arr)];
// 不加...return出来的是一个对象
}
console.log('=====set', set([1, 2, 3, 3, 4]));
使用object
function obj(arr) {
let newArr = [];
let obj = {};
for (let i = 0; i < arr.length; i += 1) {
obj[arr[i]] = arr[i];
}
newArr = [...Object.keys(obj)];
return newArr;
}
console.log('=======obj', obj([1, 2, 2, 3]));
复制代码
一个字符在字符串中出现最多的次数
遍历字符串
function countChar(str) {
let obj = {};
for (let char of str) {
if (!obj[char]) {
obj[char] = 1;
} else {
obj[char] += 1;
}
}
let max = 0;
let c = null;
for (let i in obj) {
if (obj[i] > max) {
max = obj[i];
c = i;
}
}
return c;
}
console.log(countChar('aaabccccc'));
复制代码
使用reduce
function countChar(str) {
let result = null;
Array.prototype.reduce.call(str, function (pre, current) {
if (pre[current]) {
pre[current]++;
} else {
pre[current] = 1;
}
result = pre;
return result;
}, {});
return result;
}
// pre => {} => initial(第一轮)
// current => str[0](第一轮)
console.log(countChar('aaabccccc'));
复制代码
不用临时变量,交换两个变量的值
结构赋值
function swap(a, b) {
return [a, b] = [b, a];
}
console.log('======swap', swap(3, 5));
复制代码
运用+ ,-运算符
function swap(a, b) {
b = b - a;
a = a + b;
b = a - b;
return [a, b];
}
b-a+a+b+a-b
复制代码
找出数组中最大差值
使用reduce
function getMax(arr) {
let pree = {};
arr.reduce(function (pre, current) {
if (pre.min > current) {
pre.min = current;
}
if (pre.max < current) {
pre.max = current;
}
pree = pre;
return pree;
}, {
min: arr[0],
max: arr[0]
})
return pree.max - pree.min;
}
console.log('===============getMax', getMax([1, 2, 3, 3, 9, ]));
复制代码
js的Math对象max()和min()方法
function getMax(arr) {
let max = Math.max.apply(Math, arr);
let min = Math.min.apply(Math, arr);
return max - min;
}
复制代码
排序
冒泡排序
1、比较相邻的两个元素, 如果前一个比后一个大, 则交换位置。 2、 第一轮的时候最后一个元素应该是最大的一个。 3、 按照步骤一的方法进行相邻两个元素的比较, 这个时候由于最后一个元素已经是最大的了, 所以最后一个元素不用比较。
function bubbleSort(arr) {
for (let i = 0; i < arr.length - 1; i += 1) {
for (let j = 0; j < arr.length - i - 1; j += 1) {// i就是第一轮的时候最后一个最大的,第二轮的时候2,最后两个最大的
if (arr[j] > arr[j + 1]) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
console.log('==========bubbleSort', bubbleSort([10, 7, 8, 4, 9, 80, 1, 5, 14, 3, 90]));
复制代码
快速排序
1、找基准(一般是以中间项为基准) 2、遍历数组,小于基准的放在left,大于基准的放在right 3、递归
function quickSort(arr) {
//如果数组<=1,则直接返回
if (arr.length <= 1) {
return arr;
}
let pivotIndex = Math.floor(arr.length / 2);
//找基准,并把基准从原数组删除
let pivot = arr.splice(pivotIndex, 1)[0];
//定义左右数组
let left = [];
let right = [];
//比基准小的放在left,比基准大的放在right
for (let i = 0; i < arr.length; i++) {
if (arr[i] <= pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
//递归
return quickSort(left).concat([pivot], quickSort(right));
}
复制代码
选择排序
function selectionSort(arr) {
var len = arr.length;
var minIndex, temp;
for (var i = 0; i < len - 1; i++) {
minIndex = i;
for (var j = i + 1; j < len; j++) {
if (arr[j] < arr[minIndex]) { //寻找最小的数
minIndex = j; //将最小数的索引保存
}
}
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
return arr;
}
selectionSort([3, 5, 2, 8, 9, 7, 6])
//[2, 3, 5, 6, 7, 8, 9]
复制代码
斐波那契数列i<=1=>push,否则循环(0、1、1、2、3、5、8、13、21、34、……)
function getFibonacci(n) {
var fibarr = [];
var i = 0;
while (i < n) {
if (i <= 1) {
fibarr.push(i);
} else {
fibarr.push(fibarr[i - 1] + fibarr[i - 2])
}
i++;
}
return fibarr;
}
getFibonacci(9); //拿到9个
[0、1、1、2、3、5、8、13、21]
复制代码
递归
function fibo(n) {
if (n <= 2) {
return 1;
} else {
return fibo(n - 1) + fibo(n - 2);
}
}
console.log('======', fibo(8));
复制代码
尾数调用优化
function fibo(n, res1 = 1, res2 = 1) {
if (n <= 2) {
return res2;
} else {
// 3 fibo(2,3,2);
// 4 fibo(3,1,2);
// 3 fibo(2,1,3);
return fibo(n - 1, res2, res1 + res2);
}
}
console.log('======', fibo(8));
复制代码
迭代
// 0,1,1,2,3 res1,res2从1,1 变成1,2(sum),变成2,3(sum)=>sum前两个的合
function fibo(n) {
var res1 = 1;
var res2 = 1;
var sum = res2;
for (var i = 2; i < n; i++) {
sum = res1 + res2;
res1 = res2;
res2 = sum;
}
return sum;
}
复制代码
随机生成指定长度的字符串
function randomStr(n) {
let str = '';
let string = 'abcdefghijklmnopqrstuvwxyz9876543210';
for (let i = 0; i < n; i += 1) {
str += string.charAt(Math.floor(Math.random() * string.length));
}
return str;
}
console.log('=========randomStr', randomStr(4));
复制代码
实现clone(Number、String、Object、Array、Boolean)进行值复制
小知识点 let arr=[1,2]; let obj={a:1}; Object.prototype.toString.call(arr)===>"[object Array]" Object.prototype.toString.call(obj)===>"[object object]"
function clone(obj) {
var result;
switch (typeof obj) {
case 'undefined':
break;
case 'string':
result = obj + '';
break;
case 'number':
result = obj - 0;
break;
case 'boolean':
result = obj;
break;
case 'object':
if (obj === null) {
result = null;
} else {
if (Object.prototype.toString.call(obj).slice(8, -1) === 'Array') {
result = [];
for (var i = 0; i < obj.length; i++) {
result.push(clone(obj[i]));
}
} else {
result = [];
for (var k in obj) {
result[k] = clone(obj[k]);
}
}
};
break;
default:
result = obj;
break;
}
return result
}
复制代码
匹配字符串的子字符串
substr( ) 和 substring( )的区别 stringvar.substr(start [, length] ):返回一个从指定位置开始的指定长度的子字符串。 strVariable.substring(start,end ):返回位于String对象中指定位置的子字符串。
let str = "aaaaaadffgggggggggggjhgfd";
let search = "adff";
let start = str.indexOf(search); //获得字符串的开始位置
let result = str.substring(start, start + search.length); //截取字符串
console.log('===result', result);
复制代码
实现字符串全排列
const anagrams = str => {
if (str.length <= 2) return str.length === 2 ? [str, str[1] + str[0]] : [str];
return str.split('').reduce((acc, letter, i) =>
acc.concat(anagrams(str.slice(0, i) + str.slice(i + 1)).map(val => letter + val)), []);
};
复制代码