刷题-【leetcode】-JavaScript笔记

1. 输入输出

1.1 JavaScript v8 输入输出

输入：
1 5 
10 20
输出：
6 30 

var line;
while((line = read_line()) != ""){
var a=line.split(' ')[0];
print(a);
}

1.2 Node.js输入输出

单行输入

//这两行必须引入
var readline = require('readline')
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})

//line就是一行的数据
rl.on('line',function(line){
    //将数据按空格分开，返回一个数组
    var tokens = line.split(' ')

    //处理数据
    //打印数组每个元素
    for(let i = 0; i<tokens.length; i++){
        console.log(tokens[i])
    }
})

多行输入

//必须引入
var readline = require('readline')
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal:false
})

//总行数默认为-1
var n = -1
//保存每行数据
var arr = []
//当前读取的行
cur_line = 0
rl.on('line', function(line){
    if (n < 0) {
        //第一行数据去除空白字符，转为整数，做为新的行数
        n = parseInt(line.trim())
    } else {
        //处理数据
        //读取每行数据，去掉空格，保存到一个数组
        var tokens = line.split(' ')
        //将数组加入到大的数组中
        arr.push(tokens)
        //当前行数+1
        cur_line += 1
    }

    //当行数读满
    //这里一定要是全等===
    if(cur_line === n) {
        //打印每个数组
        for (elem of arr) {
            console.log(elem)
        }
    }
})

数组输出

数组输出为1 2 3

let a=[1,2,3];
console.log(a.join(' '));

let a=[1,2,3];
console.log(...a);

var line;
while(line=readline()) {
    var he = line.split(' ');
    var nums = 0;
    for(var i=0;i<he.length;i++) {
        nums += parseInt(he[i]);
    }
    console.log(nums);
} 

输入：
5
c d a bb e 
输出：
a bb c d e 

var n = readline();
var line = readline();
const arr = line.split(' ').sort().join(' ');
console.log(arr); 

1.1 栈

描述
请你实现一个栈。
操作：
push x：将 加x\x 入栈，保证 x\x 为 int 型整数。
pop：输出栈顶，并让栈顶出栈
top：输出栈顶，栈顶不出栈\

输入描述：
第一行为一个正整数 n\n ，代表操作次数。(1 \leq n \leq 100000)(1≤n≤100000)
接下来的 n\n ，每行为一个字符串，代表一个操作。保证操作是题目描述中三种中的一种。c

输入：

6
push 1
pop
top
push 2
push 3
pop

输出：
1
error
3

let n = parseInt(readline()); // 读取行数 
var stack =;
while(n--) {
    var strArr = readline().split(' ');
    switch (strArr[0]) {
        case 'push':
            stack.push(parseInt(strArr[1]));
            break;
        case 'pop':
            if(stack.length == 0) console.log('error');
            else {
                console.log(stack.pop());
            }
            break;
        case 'top':
            if(stack.length == 0) console.log('error');
            else console.log(stack[stack.length-1]);
            break;
    }  
}

1.2 队列

描述
请你实现一个队列。
操作：
push x：将 x\x 加入队尾，保证 x\x 为 int 型整数。
pop：输出队首，并让队首出队
front：输出队首：队首不出队

输入描述： 第一行为一个正整数 n\n ，代表操作次数。(1 \leq n \leq 100000)(1≤n≤100000) 接下来的
n\n ，每行为一个字符串，代表一个操作。保证操作是题目描述中三种中的一种。

输入：
6
push 1
pop
front
push 2
push 3
pop

输出：
1
error
2

let n = readline();
let  quene=[];
while(n--)  {
  line = readline().split(" ");
  if (line.length == 2) {
    quene.push(line[1]);
  } else {
    if (quene.length == 0) {
      console.log("error");
    } else if (line[0] == "pop") {
      console.log(quene.shift());
       
    } else {
      console.log(quene[0]);
    }
  }
}

1.3 链表

描述
请你实现一个链表。

操作：
insert x y：将yy加入链表，插入在第一个值为xx的结点之前。若链表中不存在值为xx的结点，则插入在链表末尾。保证xx,yy为int型整数。
delete x：删除链表中第一个值为xx的结点。若不存在值为xx的结点，则不删除。
输入描述：
第一行输入一个整数nn (1\le n \le 10^41≤n≤10
4
)，表示操作次数。
接下来的nn行，每行一个字符串，表示一个操作。保证操作是题目描述中的一种。

输出描述：
输出一行，将链表中所有结点的值按顺序输出。若链表为空，输出"NULL"(不含引号)。

输入
5
insert 0 1
insert 0 3
insert 1 2
insert 3 4
delete 4

输出：
2 1 3

function link() {
    var line = readline();
    var n = parseInt(line);
    var arr = [];
    while(n--) {
        var ops = readline().split(' ');
        var x = parseInt(ops[1]);
        var y;
        if(ops.length == 3) y = parseInt(ops[2]);      
        var indexX = arr.indexOf(x);  //值为x的节点的索引号
        if(ops[0] == 'insert') {
            if(indexX == -1) {
                arr.push(y);
            } else {
                arr.splice(indexX, 0, y);//在x 后面加一个y
            }
        } else if(ops[0] == 'delete') {
            if(indexX != -1) {
                arr.splice(indexX,1);//删除x
            }
        }
    }

1.4 树

层次遍历BFS

function PrintFromTopToBottom(root)
{
    // 没有，就返回空
    if(!root) return []
    let res=[]
    let queue = []
    queue.push(root)// 先将根节点放入队列里面
    while(queue.length){
        let node=queue.shift() // 取出对头, 出队
        res.push(node.val)
        if(node.left) queue.push(node.left)
        if(node.right) queue.push(node.right)
    }
    return res
}

递归
给定的二叉树，变换为源二叉树的镜像

function Mirror( pRoot ) {
    // write code here
    if(!pRoot) return pRoot
    let tmp=pRoot.left
    pRoot.left=pRoot.right
    pRoot.right=tmp
    Mirror(pRoot.left)
    Mirror(pRoot.right)
    return pRoot
    
}

给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径

function hasPathSum( root ,  sum ) {
    // write code here
    if(!root) return false;
    if(sum==root.val && root.left==null && root.right==null) return true;
    return hasPathSum(root.right,sum- root.val)||hasPathSum(root.left,sum- root.val)
}

输入一颗二叉树的根节点root和一个整数expectNumber，找出二叉树中结点值的和为expectNumber的所有路径。

function FindPath(root, expectNumber)
{
    // write code here
    if(!root) return 0
    let res=[]
    let sum=0 
    let tmp=[]
    dfs(root,expectNumber,tmp,sum,res)
    return res
    function dfs(root,expectNumber,tmp,sum,res){
        tmp.push(root.val)
        sum+=root.val
//         if(!root.left&&!root.right&&sum==expectNumber) res.push([...tmp])
        if(!root.left&&!root.right&&sum==expectNumber) res.push(tmp.slice(0)) //复制数组
        if(root.left) dfs(root.left,expectNumber,tmp,sum,res)
        if(root.right) dfs(root.right,expectNumber,tmp,sum,res)
        tmp.pop()
    }
}

res.push([…tmp])
res.push(tmp.slice(0)) //复制数组

2.数组

2.1创建c数组有两种方式

2.1.1使用 Array 构造函数：

var arr1 = new Array(); //创建一个空数组
var arr2 = new Array(20); // 创建一个包含20项的数组
var arr3 = new Array(“lily”,“lucy”,“Tom”); // 创建一个包含3个字符串的数组

2.1.2使用数组字面量表示法：

var arr4 = []; //创建一个空数组
var arr5 = [20]; // 创建一个包含1项的数组
var arr6 = [“lily”,“lucy”,“Tom”]; // 创建一个包含3个字符串的数组

2.2 常用方法

join()=拼接成字符串join(),join('-')  例如：1，2，3  =>  1-2-3
push()=从后面加数据
pop()=删除最后一个
shift()=删除第一个shift()
unshift()=在前面加数据
sort() =数组排序arr.sort(),从小到大排序sort（function（a,b）{return a - b}）
reverse()   =数组反转 arr.reverse（）
concat()=拼接数组arr1.concat(arr2)
=====
slice() =返回截取的新数组，包前不包后res = arr.slice（开始索引，结束索引）
splice()=返回新数组（被删除的数据） res=arr.splice（开始索引，多少个，value）

splice()实现删除、替换、添加

 // 删除
  list.splice(0,1);  // 删除  -> 从下标为0开始,项数为1
  console.log(list); // [2,3]

  
  //替换
  list.splice(0,1,4); // 替换 -> 从下标为0开始,项数为1的数组元素替换成4
  console.log(list);  // [4,2,3]
  list.splice(0,2,4); // 替换 -> 从下标为0开始,项数为2的数组元素替换成4(即4,2整体替换成4)
  console.log(list);  // [4,3]
  
  //添加
  list.splice(1,0,5); // 表示在下标为1处添加一项5
  console.log(list);    // [1,5,2,3]        

ES5新增

indexOf() =接收两个参数：要查找的项和（可选的）表示查找起点位置的索引,返回*第一次*出现的索引。没有则返回-1
lastIndexOf() =接收两个参数：要查找的项和（可选的）表示查找起点位置的索引,从后往前找


forEach()   =遍历数组 arr.forEach（function（item，index，arr）{}）

map() =映射数组map（function（item，index，arr）{return item*10}）  // 将数组每一个元素*10
filter() = 返回过滤好的新数组filter（function（item，index，arr）{return item>150}） 将数组小于150的元素删除
every() =判断是否每一项都满足条件,every（function（item，index，arr）{return item>150}）， 判断是否大于150,返回布尔
some() =判断是否有某一项都满足条件some（function（item，index，arr）{return item>150}） 判断是否有满足大于150的元素
reduce()
reduceRight() （ES5新增）

reduce()

1 reduce()最简单的用法就是累加和累乘

    let arr3 = [1,3,4,6,7];
    let sum3 = arr3.reduce((pre,cur)=> pre+cur)
    let multiply = arr3.reduce((pre,cur) => pre*cur)
    console.log(sum3) // 21
    console.log(multiply) // 504

2 reduce()高级用法：数组去重

    // 数组去重
    let arr4 = [1,3,2,5,3,1,2,7,8];
    let newArr = arr4.reduce((pre,cur)=>{
      if(!pre.includes(cur)){
        return pre.concat(cur)
      } else {
        return pre
      }
    },[]);
    console.log(newArr, '数组去重') // [1, 3, 2, 5, 7, 8] 

3 reduce()高级用法：将二维数组转化为一维数组

		let arr2 = [[0, 1], [2, 3], [4, 5]]
        let newArr2 = arr2.reduce((pre, cur) => {
            return pre.concat(cur);
        },[])
       console.log('newArr2', newArr2);
       //"newArr2"[0, 1, 2, 3, 4, 5]

4 reduce()高级用法：多维数组转成一维数组

    // 将多维数组转换成一维数组
    let arr6 = [1,3,[4,5,6,[7,8,4]],[7,0,[2,4],9]];
    let newArr3 = this.flatArr(arr6);
    console.log(newArr3, '多维转一维') // [1, 3, 4, 5, 6, 7, 8, 4, 7, 0, 2, 4, 9]
 
  
   flatArr(arr){
      return arr.reduce((pre,cur)=>{
        return pre.concat(Array.isArray(cur)?this.flatArr(cur):cur)
      },[])
   }

2.3 Math 对数组操作

获取数组中最小值

var arr=[1,2,3,4,5,6,10,11,12,13,14,15];
Math.min.apply(null,arr);//获取数组中最小值

获取数组中最大值

var arr=[1,2,3,4,5,6,10,11,12,13,14,15];
Math.max.apply(null,arr);//获取数组中的最大值

3.Set（）、Map（）

3.1 Set（）

Set结构不会添加重复的值

const s = new Set();
 
[2,3,5,4,5,2,2].forEach(x => s.add(x));
 
for(let i of s) {
  console.log(i);
//2 3 5 4

创建、添加元素、添加元素、添加元素、添加元素

//new Set()方式创建
let v = new Set([1,2,3,3,5])
//使用 add 方法添加元素
v.add(1)
//删除元素
v.delete(5)
//获取 Set 中元素个数,使用 size
v.size
//判断 Set 中是否包含某个元素
v.has(5)

遍历 Set、Set 转换成数组

//forEach形式
v.forEach(t=>{
    console.log(t)
})
//for of 形式
for(let t of v) {
    console.log(t)
}
//Set 转换成数组
let a = Array.from(v)

3.2 Map()

它允许存储【键，值】对，其中任何值都可以用作键或值；Map集合中的键和值可以是任何类型，并且如果使用集合中已存在的键将值添加到Map集合中，新值将替换旧值。

// 创建新Map
var m = new Map(); 
// 添加新的key-value
m.set('Adam', 67); 
m.set('Bob', 59);
m.set('zhang', "zhansghan");
m.set('Bob', 55555);// 如果已经有的key会更新

// 是否存在key 'Adam': true
m.has('Adam'); 
// 用来获取一个Map对象指定的元素，返回的是键，如果不存在则会返回undefined
m.get('Adam'); // 67
// 删除key ，'Adam'
m.delete('Adam'); 
m.get('Adam'); // undefined

//获取长度
m.size

keys()	//返回 Map 对象中键的数组。
values()	//返回 Map 对象中值的数组。

m.keys().next().value //返回第一个键的值
m.values().next().value//返回第一个值的值

遍历map

//forEach
map.forEach(function(value,key){
    console.log(key, value);
});

//for-of遍历

//遍历结果是数组
for(let item of m){
  console.log(item);
}

 //遍历属性值
for(let item of m.values()){
  console.log(item);
}

//遍历属性
for(let item of m.keys()){
  console.log(item);
}