文章目录
流程控制语句
i love china字符串反转
var str = 'i love china';
// 将字符串转为数组 split(' ')
var res = str.split(" ");//['i','love','china']
var result = '';
for (var i = res.length - 1; i >= 0; i--) {
result += res[i] + ' '
}
console.log(result) //china love i
1~1000以内完美数
(数本身=因子之和 。6=1+2+3)
function perfect(num) {
// 第一层for循环处理完美数本身
for (var i = 1; i <= num; i++) {
// 拿一个变量求因子之和
var sum = 0;
// 处理因子
for (var j = 1; j < i; j++) {
if (i % j == 0) {
sum += j;
}
}
if (i == sum) {
console.log(i + '是完美数')
}
}
}
perfect(1000)
//6是完美数
//28是完美数
//496是完美数
1 2 3 4 组合三位数,个十百位都不相同
for (var i = 1; i <= 4; i++) {
for (var j = 1; j <= 4; j++) {
for (var k = 1; k <= 4; k++) {
if (i != j && i != k && j != k) {
// console.log(i*100+j*10+k*1)
console.log(i + '' + j + '' + k)
}
}
}
}
// 123
// 124
// 132
// 134
// 142
// 143
// 213
// 214
// 231
// 234
// 241
// 243
// 312
// 314
// 321
// 324
// 341
// 342
// 412
// 413
// 421
// 423
// 431
// 432
冒泡排序
/**
* 冒泡排序核心思路:
* 1.比较相邻两项,将大的往后放,将小的往前放 交换位置
* 2.每一轮比较后最大的数在最后面
* 3.由于最后一个数是最大得数 不参与这一轮比较
* 外部总共比较多少轮 每一轮比较次数
*
* 第一轮:20 18 [18,20,27,19,35]
* 20 27 [18,20,27,19,35]
* 27 19 [18,20,19,27,35]
* 27 35 [18,20,19,27,35]
* 第二轮 18 20 [18,20,19,27,35]
* 20 19 [18,19,20,27,35]
* 20 27 [18,19,20,27,35]
* 第三轮: 18 19 [18,19,20,27,35]
* 19 20 [18,19,20,27,35]
* 第四轮 18 19 [18,19,20,27,35]
*/
var arr = [20,18,27,19,35];//进行排序 从小到大排序
function bSort(arr){
// 控制外面比较轮数
for(var i=0;i<arr.length-1;i++){
// 控制每一轮比较次数
for(var j=0;j<arr.length-1-i;j++){
// 比较前一项和后一项
if(arr[j]>arr[j+1]){
//交换位置 把后一项存起来
var temp = arr[j+1];
// 把小得往前放
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
return arr
}
console.log(bSort(arr));
6的阶乘
function fc(n) {
// 设置跳出条件
if(n==1){return 1}
return n * fc(n - 1)
}
var res = fc(6);
console.log(res)/720/
/**
* 递归就是函数自身调用自身
* 使用场景:深拷贝 斐波那契数列 阶乘
* 6得阶乘 6 * 5 * 4 * 3 * 2 *1
* 跳出条件
*/
/**
* 1阶乘 1 fc(1)
* 2 2*fc(1) = fc(2)
* 3 3*fc(2)
* 4 4*fc(3)
* 5 5*fc(4)
* 6 6*fc(5)
*/
封装函数实现10的阶乘
/**
* 10=10*9*8*7*6*5*4*3*2*1=3628800
* 封装一个函数实现10的阶乘
*/
function fc(num){
var str =num+'=',sum=1;
for(var i=num;i>=1;i--){
sum*=i;
if(i==1){
str+=i+'='
}else{
str+=i+'*'
}
}
console.log(str + sum);
}
fc(10)//10=10*9*8*7*6*5*4*3*2*1=3628800
水仙花数
一个数个位立方+十位立方+百位立方 = 数
100-1000
function sum(){
for(var i=100;i<1000;i++){
var a = parseInt(i/100);//百位数字
var b = parseInt(i%100/10);//十位数字
var c = i%10;
// if(a*a*a+b*b*b+c*c*c == i){
// console.log(i+'是水仙花数');
// }
if(Math.pow(a,3)+Math.pow(b,3)+Math.pow(c,3)==i){
console.log(i+'是水仙花数');
}
}
}
sum()
// 153是水仙花数
// 370是水仙花数
// 371是水仙花数
// 407是水仙花数
给定一个数组[2,5,7,11],target=9;如果数组元素之和等于target 返回数组元素下标
var nums = [2,5,7,11,4],target = 9;
function add(nums,target){
var arr =[];
for(var i=0;i<nums.length;i++){
for(var j=i+1;j<nums.length;j++){
if(nums[i]+nums[j]==target){
// 给数组添加元素
arr.push([i,j])
}
}
}
return arr
}
var res = add(nums,target);
console.log(res) //[ [ 0, 2 ], [ 1, 4 ] ]
var arr0=[2,5,7,11,4];
var arr1=[];
function add(){
for(var i=0;i<arr0.length;i++){
for(var j=0;j<arr0.length;j++){
if(i!=j){
if(arr0[i]+arr0[j]==9){
console.log([i,j])
arr1.push([i,j])
}
}
}
}
return arr1
}
console.log(add())
// [ 0, 2 ]
// [ 1, 4 ]
// [ 2, 0 ]
// [ 4, 1 ]
// [ [ 0, 2 ], [ 1, 4 ], [ 2, 0 ], [ 4, 1 ] ]
求字符串中最长单词长度 / 求最长单词
var str = 'he is jumped ahdjksnadkjfhkjas';
var res = str.split(' ');//['he','is','','']
function maxLength(){
var max = 0;//最长单词长度
for(var i=0;i<res.length;i++){
if(res[i].length>max){
max = res[i].length
}
}
return max
}
function maxWord(){
var max = 0;
for (var i = 0; i < res.length; i++) {
if (res[i].length > res[max].length) {
max = i
}
}
return res[max]
}
console.log(maxLength()); //17
console.log(maxWord()); //ahdjksnadkjfhkjas
重构数组方法
Array.prototype.方法名 = function () { }
//.pop() 要求重写myPop实现pop一样得功能
Array.prototype.myPop = function () {
if (this.length > 0) {
var last = this[this.length - 1];
this.length--;
return last;
}else{
return undefined
}
};
var arr = [];
var res = arr.myPop();//myPop方法被arr调用 方法内部this指向arr
console.log(res, arr);
//push
Array.prototype.myPush = function(){
// arr[arr.length] 将新增数组元素添加给原数组元素最后一项下一项
// 循环遍历实际参数 'tom' 'jack' 'zack'
for(var i=0;i<arguments.length;i++){
// 将每一个实际参数依次从末尾添加给原数组
this[this.length] = arguments[i]
}
return this.length
}
var arr = [1,2,3,4];
var res = arr.myPush('tom','jack','zack','world');
console.log(res,arr)
//shift
Array.prototype.myShift = function(){
// 返回第一项
var first = this[0];
for(var i=0;i<this.length;i++){
// 将后面的数组元素往前移动一项
this[i] = this[i+1]
}
this.length--;
return first
}
var arr = [1,2,3,4,5];
var res = arr.myShift();
console.log(res,arr);
//unshift
Array.prototype.myUnshift = function(){
// 获取新数组长度
var length = this.length + arguments.length;
// [1,2,3,4,5]//4 i=4
// [,,,1,2,3,4,5]//7 i=4+arguments.length i 7 i = i-arguments.length
// ['tom','larry','hello',1,2,3,4,5]
// 将原数组元素向后移动arguments.length位
for(var i = length-1;i>=0;i--){
// 当i等于arguments.length-1 原数组元素移动完成
if(i>arguments.length-1){
this[i] = this[i-arguments.length]
}else{
this[i] = arguments[i]
}
}
// 新数组下标i为auguments.length-1
// 返回新数组长度
return length
}
var arr = [1,2,3,4,5];
var res = arr.myUnshift('tom','larry','hello');
console.log(res,arr);
//.reverse()
Array.prototype.myReverse = function(){
var newArr = [];
// [5,4,3,2,1]---->[0,1,2,3,4]
for(var i=this.length-1;i>=0;i--){
// newArr.push(this[i]);
newArr[newArr.length] = this[i]
}
arr = newArr
return arr
}
var arr = [1,2,3,4,5];
var res = arr.myReverse();
console.log(res,arr);
/**
* 迭代方法 forEach
*/
var arr = [1, 2, 3, 4, 5];
Array.prototype.myForEach = function (callback) {
// callback--->function(){}
for (var i = 0; i < arr.length; i++) {
callback(arr[i], i, arr)
}
};
arr.myForEach(function (item, index, arr) {
console.log(item, index, arr)
});
/**
* every 判断数组元素是否符合表达式 只要有一项不符合直接返回false 跳出循环
*/
Array.prototype.myEvery = function (callback) {
for (var i = 0; i < arr.length; i++) {
// 把函数调用当作条件的判断
if (!callback(arr[i], i, arr)) {
return false
}
}
return true
}
var arr = [1, 2, 3, 4, 5];
var res = arr.myEvery(function (item, index, arr) {
return item > 1
});
console.log(res, arr);
/**
* some 判断数组元素是否符合表达式 只要有一个符合就返回true 跳出循环
*/
Array.prototype.mySome = function (callback) {
for (var i = 0; i < arr.length; i++) {
// 只要有一个满足条件 直接返回true
if (callback(arr[i], i, arr)) {
return true
}
}
return false
}
var arr = [1, 2, 3, 4, 5];
var res = arr.mySome(function (item, index, arr) {
return item > 5
});
console.log(arr, res);
/**
* filter 过滤符合条件数组元素组成新数组
*/
Array.prototype.myFilter = function (callback) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (callback(arr[i], i, arr)) {
// newArr.push(arr[i])
newArr[newArr.length] = arr[i]
}
}
return newArr
}
var arr = [1, 2, 3, 4, 5];
var res = arr.myFilter(function (item, index, arr) {
return item > 4
});
console.log(res, arr);
/**
* map 映射 对每一个数组元素进行操作
*/
Array.prototype.myMap = function (callback) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
newArr[newArr.length] = callback(arr[i], i, arr)
}
return newArr
};
var arr = [1, 2, 3, 4, 5];
var res = arr.myMap(function (item, index, arr) {
return item + 5
});
console.log(res, arr)
数组查重
function checkForDuplicatesWithCount(arr) {
let duplicates = {};
arr.forEach((element, index) => {
if (arr.indexOf(element, index + 1) !== -1) {
if (duplicates[element]) {
duplicates[element]++;
} else {
duplicates[element] = 2; // 第一次出现时是第二次,因此从2开始计数
}
}
});
return duplicates;
}
// 示例用法
const array = [1, 2, 3, 4, 2, 5, 6, 3];
const duplicatesWithCount = checkForDuplicatesWithCount(array);
for (const key in duplicatesWithCount) {
console.log(key + " 重复了 " + (duplicatesWithCount[key] - 1) + " 次");
}
//其他方法
function checkForDuplicatesWithCount2(arr) {
let duplicates = {};
arr.forEach(element => {
duplicates[element] = (duplicates[element] || 0) + 1;
});
return Object.fromEntries(
Object.entries(duplicates).filter(([key, value]) => value > 1)
);
}
// 示例用法
const array = [1, 2, 3, 4, 2, 5, 6, 3];
const duplicatesWithCount2 = checkForDuplicatesWithCount2(array);
for (const key in duplicatesWithCount2) {
console.log(key + " 重复了 " + (duplicatesWithCount2[key] - 1) + " 次");
}
//set方法
function findDuplicateElements(arr) {
let set = new Set();
let duplicates = new Set();
arr.forEach(element => {
if (set.has(element)) {
duplicates.add(element);
} else {
set.add(element);
}
});
return Array.from(duplicates);
}
let arr = [1, 2, 3, 4, 2, 3, 5, 6, 1];
let duplicates = findDuplicateElements(arr);
console.log(duplicates); // Output: [2, 3, 1]
//双重for循环
function findDuplicateElements(arr) {
let duplicates = [];
for (let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i] === arr[j] && !duplicates.includes(arr[i])) {
duplicates.push(arr[i]);
}
}
}
return duplicates;
}
let arr = [1, 2, 3, 4, 2, 3, 5, 6, 1];
let duplicateElements = findDuplicateElements(arr);
console.log(duplicateElements); // Output: [2, 3, 1]
//map方法
function findDuplicates(arr) {
let map = new Map();
let duplicates = [];
for (let i = 0; i < arr.length; i++) {
if (map.has(arr[i])) {
map.set(arr[i], map.get(arr[i]) + 1);
} else {
map.set(arr[i], 1);
}
}
map.forEach((value, key) => {
if (value > 1) {
duplicates.push({ element: key, count: value });
}
});
return duplicates;
}
// 示例用法
let arr = [1, 2, 3, 2, 4, 5, 3, 6, 4, 7, 8, 9, 7];
let result = findDuplicates(arr);
console.log(result);
数组去重
//双层for循环去重
//对比前一项和后一项是否相等 相等删除后一项,修正下标
var arr = [1,2,3,4,5,4,1,3,2,1];
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--;
}
}
}
return arr
}
console.log(unique(arr)); //[ 1, 2, 3, 4, 5 ]
// 2.使用indexOf去重 3.使用lastIndexOf去重
// 思路:创建一个新的数组 判断重复数组元素是否存在新数组中 不存在直接添加到新数组
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
function unique(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
// 判断每一项数组元素是否存在新数组中 不存在则添加到新数组中
newArr.indexOf(arr[i]) === -1 ? newArr.push(arr[i]) : ""
// newArr.indexOf(arr[i]) === -1 ? newArr[newArr.length] = arr[i] : ""
}
return newArr
}
console.log(unique(arr));
// 3.利用includes方法进行数组去重
// 检测数组元素是否存在数组中 存在返回true 不存在返回false
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
function unique(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
// newArr.includes(arr[i])===false?newArr[newArr.length]=arr[i]:""
if (!newArr.includes(arr[i])) {
newArr.push(arr[i])
}
}
return newArr
}
console.log(unique(arr))
//4. forEach + includes /indexOf /lastIndexOf
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
function unique(arr) {
var newArr = [];
arr.forEach(function (item) {
newArr.indexOf(item) === -1 ? newArr.push(item) : ""
// newArr.lastIndexOf(item) === -1 ? newArr.push(item) : ""
// newArr.includes(item) === false ? newArr.push(item) : ""
})
return newArr
}
console.log(unique(arr));
// 5.利用filter方法 + includes/indexOf/lastIndexOf
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
function unique(arr) {
var newArr = [];
return arr.filter(function (item) {
return newArr.indexOf(item) === -1 ? newArr.push(item) : ""
})
}
console.log(unique(arr));
//6.利用set去重 set成员是唯一的
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
var set = new Set(arr);
console.log(Array.from(set));
console.log([...set]);
数组扁平化
[1,2,[3,4,5,[6,7,8,[9,10]]]]-------> [1,2,3,4,5,6,7,8,9,10]
//1.利用递归实现数组扁平化
var arr = [1, 2, [3, 4, 5, [6, 7, 8, [9, 10, [11, 12, [13, 14]]]]]];
function flat(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (Array.isArray(arr[i])) {
newArr = newArr.concat(flat(arr[i]))
} else {
newArr.push(arr[i])
}
}
return newArr;
}
console.log(flat(arr));
//2.
var arr = [1, 2, [3, 4, 5, [6, 7, 8, [9, 10, [11, 12, [13, 14, 'hello']]]]]];
// console.log(arr.toString().split(",")); '1' '2'
function flat(arr) {
return arr.toString().split(',').map(function (item) {
if (isFinite(+item) === false) {
return item
} else {
return +item
}
})
}
console.log(flat(arr));
//3.利用es6 flat方法进行数组扁平化 展开数组 n Infinity
var arr = [1, 2, [3, 4, 5, [6, 7, 8, [9, 10, [11, 12, [13, 14, 'hello']]]]]];
var res = arr.flat(Infinity);
console.log(res, arr);