挖个刷题坑

题目

dom的操作，删除，移动，复制，插入，前插后插，指定插一类。
事件的处理，兼容性写法，参数作用，扑获冒泡，委派代理。
ie下的一些兼容性问题，js的，举例。
动画方面，加速度，重力模拟实现。
正则，基本的用法和相关函数作用考查。
闭包，原型链，作用域，变量引用，类继承方法。
内存泄露的原因和场景。
h5里一些新增api的了解。
性能优化和重构知识。

一,数据结构与算法

1.二叉树的遍历

改非递归

2. 排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TIyWgmf2-1617450753002)(…/刷题/mk图片/排序.jpg)]

不稳定排序的意思是在排序过程中，相等的两个数比较之后不会改变其原来的位置，即不需要交换。

常见的稳定排序有：

冒泡排序，插入排序，归并排序，基数排序。

常见的不稳定排序有：

选择排序，堆排序，希尔排序，快速排序。

冒泡排序

function sort(arr){
//轮数最多为length-1
 for(var i=0;i<arr.length-1;i++){
 //比较次数最多为length-i-1
 for(var j=0;j<arr.length-i-1;j++){
 if(arr[j]>arr[j+1]){
 var hand=arr[j];
 arr[j]=arr[j+1];
 arr[j+1]=hand;
 }
 }
 }
 return arr;
}

快速排序

// 快速排序
let quickSort = function(arr) {
    if (arr.length <= 1) {
        return arr;
    };
    let mid = arr[Math.round(arr.length/2) - 1];
    let arrLeft = [];
    let arrRight = [];
    for (let i=0; i<arr.length; i++) {
    	if (arr[i] < mid) {
            arrLeft.push(arr[i]);
    	};
    	if (arr[i] > mid) {
            arrRight.push(arr[i]);
        };
    };
    console.log(quickSort(arrLeft).concat([mid], quickSort(arrRight)));
    return quickSort(arrLeft).concat([mid], quickSort(arrRight));
};
 
let testArr = [85, 24, 63, 45, 17, 31, 96, 50];
let testResult = quickSort(testArr);
console.log("testResult", testResult);

二, JS基础(字符串/数组/原型链)

Javascript 解析引擎在读取一个Object的属性的值时，会沿着原型链向上寻找，如果最终没有找到，则该属性值为 undefined, 而不是null；

1.?填写内容让下面代码支持a.name = “name1”; b.name = “name2”;

function obj(name){
    [1]
}
obj.[2]= "name2";
var a = obj("name1");
var b = new obj;

知识点: 构造函数的形式, 复杂数据类型其实是指针指向堆内存里的对象,所以要在a后面new一个b,并且b也有该属性,需要用到原型链继承

[1]: this.name = name; 但是参考答案判断了下name是否存在,有这个必要吗? 即(if(name){ this.name = name;}return this;)

1. 给定一串英文,改用驼峰命名法返回, 比如hello-world-hahaha, 返回helloWorldHahaha

function toString(str) {
    //利用数组和字符串可以按某个特殊字符分割合成
    var arr = str.split('-');//符号可更改
    console.log(arr);
    for (i = 1; i < arr.length; i++) {
        //toUpperCase,toLowerCase大小写
        arr[i] = arr[i].charAt(0).toUpperCase() + arr[i].substr(1, arr[i].length - 1);
        console.log(arr[i]);
    }
    var newStr = arr.join('')
    console.log(newStr);
}
toString(str);

知识点: 数组字符串互转; toUpperCase,toLowerCase大小写; substr切割数组

注意: 这里arr是基础类型的数组, 但JS语法很友好, 可以直接用Array对象的方法, 因为实际处理时会把arr封装成对象, 用完再删除这个对象

2.有一个数组，里面只存在 * 和 字母，比如 [‘’, ‘d’, ‘c’, ‘’, ‘e’, ‘’, ‘a’, ‘‘]。现在需要把这个数组中的所有星号移动到左边，所有的字母移动到右边，所有字母的顺序不能改变。

三, 事件的处理(捕获/冒泡/兼容性)

首先复习兼容性:

1.注册(绑定)事件的方式

传统方式: div.onclick = function(){} 都适用
方法监听(新版浏览器和IE9以上): div.addEventListener(‘click’, fnName(){},useCapture)
IE-6-8独有: div.attachEvent(‘onclick’, fnName(){})

2.对应的删除解绑事件方式

对应传统方式: eventTarget.onclick = null;
对应方法监听方式: eventTarget.removeEventListener(‘click’, fnName);
对应旧版方法监听: eventTarget.detachEvent(‘onclick’, fnName);

3.事件对象event的兼容性:

div.onclick = function(e) {//e是形参
    // e = e || window.event;	//解决IE678兼容问题
	// console.log(window.event);
                console.log(e);
            }

4.事件对象的属性方法也有兼容性问题

e.target-标准; e.srcElement–非标准,IE678,返回触发事件的对象

1.鼠标点击页面中任意标签, alert该标签的名称, 注意兼容性

document.onclick=function(e){
	e = e || window.event;//兼容IE678的事件对象
	var currentOne = e.target || e.srcElement; //兼容IE678的触发对象
	alert(currentOne.tagName)
}

说明: 利用事件的冒泡; event.target/e.srcElement指向冒泡的起点,即触发事件的对象, 而this/event.currentTarget指向绑定事件的对象; 兼容性: IE

四, DOM的操作

五, 正则

https://www.jb51.net/article/163262.htm

六, 兼容问题

七, 判断输出(闭包/提前申明)

求输出:

var b = 3;
(function() {
    b = 5;
    var b = 2;
})();
console.log(b);

输出为3;

知识点: 立即执行函数内部, 有独立的词法作用域, 参见MDN; var发生变量提升后, 结果相当于 (function(){ var b; b=5; b=2; })(), 执行完这个变量b被销毁; 而在函数外console, 相当于console.log(window.b)

八, 动态规划

1.背包问题

有n种物品,重量为weight[i,…,n]，每个物品的价值为value[i,…,n]。现在有一个背包，它所能容纳的重量为total，问：如何组合价值最高

参考: https://www.cnblogs.com/fengziwei/p/7750849.html

暴力方法: 每种物品都有放入和不放入两种状态, O(N*2)复杂度可穷举完

动态规划法:

背包问题	问题描述	思路
01背包	有n种物品,每种物品只有一个,现在有一个背包，它所能容纳的重量为total，问：如何组合价值最高	tab[j] = max(tab[j-weight[i]]+value[i],tab[j])😭{i,j|0<i<=n,0<=j<=total})
完全背包	有n种物品,每种物品有无限个,现在有一个背包,…	tab[j] = max(tab[j-weight[i]]+value[i],tab[j])😭{i,j|0<i<=n,0<=j<=total})
多重背包	有n种物品,每种物品有有限个,现在有一个背包,…

0-1:

//考虑前i个物品
for (int i = 1; i <= n; i++) {
     for (int j = m; j >= 1; j--) {
     	//如果第i个重量小于背包容量,说明第i个物品可以放进入,于是有两种可能---放了/没放
         if (weight[i] <= j) {
             f[j] = f[j] > f[j - weight[i]] + value[i] ? f[j] : f[j - weight[i]] + value[i];
         }
     }
}