一、数组

var findDisappearedNumbers = function(nums) {
// 生成一个用来返回的数组
	const newArray = [];
	// 根据数组长度遍历数组
	for(var i =1;i<=nums.length;i++){
		if(nums.indexOf(i) ==-1 ){
		// 将不存在的数加入到新数组中
			newArray.push(i)
			}
	}
	return newArray
};
}

这种做法时间复杂度为O(n^2),效率不高，可以采用
旋转数组，应进行分层
首先数组肯定是有n行n列，这样一共会有Math.floor(n/2)层需要进行旋转，而每层的范围为从[j][j]到[n-j-1][n-j-1]这一圈，而每一层在进行旋转时，需要进行分组循环，每一层一共有[j][j]-[j][n-j-1]这n-2j组数，每一组进行值的交替，交替四次，要记得保存第一项的值

var rotate = function(matrix) {
// 获取二维数组的长度
let n = matrix.length
// 获取将进行旋转的层数
let rotateNum = Math.floor(n/2)
// 然后对每一层进行旋转
for(var j =0;j<rotateNum;j++){
// 先对最外层进行旋转，最外层等价有n-1组数，同组内是相互替换的，旋转时要注意不能出现常数，要用j i 进行代替
// 每层旋转其实是从第j行j列开始，到第n-1行n-1列结束（其中每层旋转结束后对n值进行改变）
for(var i = j;i<n-j-1;i++){
// 以当前层左上角元素为初始位，保留它的值
let reserve =matrix[j][i];
    matrix[j][i] = matrix[n-i-1][j];
    matrix[n-i-1][j] = matrix[n-j-1][n-i-1];
    matrix[n-j-1][n-i-1]=matrix[i][n-j-1]
    matrix[i][n-j-1]=reserve
}
}
};

769
这道题最重要的是生成一个函数判断集合n中，是否i-j都在n[i]-n[j]中

let isInclude = function(head,tail,array){
let newArray = array.slice(head,tail+1)
for(var i = head;i<=tail;i++){
if(newArray.indexOf(i) == -1){
return false
}
}
return true
}
// 判断能分割出多少个数组
let isInclude = function(head,tail,array){
let newArray = array.slice(head,tail+1)
// 遍历从index=head到index=tail的数组内容
for(var i = head;i<=tail;i++){
if(newArray.indexOf(i) == -1){
return false
}
}
return true
}
// 判断能分割出多少个数组
function(array){
let i =0;
let j = 0;
let resultArray=[];
// 循环整个数组
while(i<=array.length){
if(isInclude(i,j,array)){
// 如果i到j内的数组内容恰好包含i-j
let newArray=array.slice(i,j+1)
resultArray.push(newArray)
// 开始进行下一组分割判断
j++;
i = j
}else{
// 如果不能满足i到j内的数组内容恰好包含i-j，让j+1
j++
}

20题，利用类似栈的数据结构解决这个问题,有两种方式，一种是自己设置映射，一种是利用MAP

function(s){
let stack = [];
for(var i =0;i<s.length;i++){
let n = stack.length
if(s[i] =='('|| s[i] =='{' || s[i] =='['){
stack.push(s[i])
}else if(n ==0){
return false
}
else if(s[i] ==')' && stack[n-1] =='(') stack.pop()
else if(s[i] ==']' && stack[n-1] =='[') stack.pop()
else if(s[i] =='}' && stack[n-1] =='{') stack.pop()
else{
return false
}
}
return true
}

921
function(s){
// 利用数组模拟栈的特性
let stack=[];
let result = 0;
for(var i =0;i<s.length;i++){
//获取数组长度
let n = stack.length
if(s[i] == ‘(’ ) stack.push(s[i])
elseif(n ==0){ result++}
else{stack.pop()}
}
}
}
//
return result+stack.length
}