二刷注意

一、链表

1.合并两个有序链表   

　　定义一个新链表，注意不仅仅要遍历两个指定链表，新的链表也要在while循环中遍历！否则永远只在第一个节点不断更新

2. 环形链表Ⅱ 

　　双指针法和set方法

　　想要链表一直遍历循环，就得用while

　　添加到set中的元素就直接是节点，而不是节点值;   

　在一次while循环里，做两次判断（第一次快指针能移动，第二次 节点相等）

3. 链表中倒数第k个节点

　　将取到的每个值放入[]中  以 list[k-1]返回  ，不用管示例

4.复杂链表的复制

　　通过Map,两次复制，第一次复制节点及其值，第二次复制next以及random, 最后返回 return map.get(head)

5. 删除排序链表中的重复元素

　　只要a,b相等，ab都要删除，用while循环

const x = cur.next.val;
while (cur.next && cur.next.val === x) {      //这里一定要加cur.next 否则力扣报错，不明白（值都有了 还考虑节点存在不存在）
cur.next = cur.next.next;
}

6. 移除链表元素

与上题类似

if (cur.next && cur.next.val==val){      //必须先判断cur.next存在

 7.做链表题注意节点和指针,，区分哑节点和指针

let dummy=new ListNode(0)

    let pre=dummy   //pre为指针

8.排序链表

做题目先判断参数为null 返回什么。否则会报错

与第一题出错一样，新的结果链表也要节点循环

9.删除链表的倒数第k个节点

1）快慢指针  快指针比慢指针多行n 步，这样快指针遍历到最后一个节点时候，慢指针下一个为要删除的。   (假设快就是最后的null)

 while(fast&&fast.next)   // 遍历链表到最后一个节点

10.两例交换链表中的节点

　　定义哑节点、temp、pre、cur节点，结束pre重新赋值给temp,作为下一次转换的哑节点

 

二、字符串

1.反转字符串

　　从两边到中心互换位置

for (let left = 0, right = n - 1; left < right;) {   区别  

for(let l=0;r=n-1;l<r){    下定义用逗号

for(let l=0,r=n-1; l<r;l++,r--){   注意冒号和逗号的区别

2. 最长回文子串与回文子串

　　使用同样的方法中心扩散法，最长回文子串无论奇数偶数个，都算 最后取最大值就行。但是回文子串不行，他增加的是个数，需要严格确定扩散中心个数

　　注意 使用s.charAt(l) == s.charAt(r) 获得字符串元素 而非是s[l] ==s[r]

 

三、二叉树

二叉树的前中后序遍历

递归:

前序遍历：

var preorderTraversal = function(root) {
 let res=[];
 const dfs=function(root){
     if(root===null)return ;
     //先序遍历所以从父节点开始
     res.push(root.val);
     //递归左子树
     dfs(root.left);
     //递归右子树
     dfs(root.right);
 }
 //只使用一个参数 使用闭包进行存储结果
 dfs(root);
 return res;
};

迭代
前序和后序遍历类似，后序压栈左右顺序和前序相反最后结果reverse
中序遍历：处理（左）顺序和访问（root）顺序是不一致的。借用指针（cur）的遍历来帮助访问节点，栈则用来处理节点上的元素。
前后序 才开始栈为stack=[root]  中序遍历初始stack=[]

if(!root) return res;  //必须加否则会报错

前序遍历:

// 入栈 右 -> 左
// 出栈 中 -> 左 -> 右
var preorderTraversal = function(root, res = []) {
    if(!root) return res; 
    const stack = [root];
    let cur = null;
    while(stack.length) {
        cur = stack.pop();
        res.push(cur.val);
        cur.right && stack.push(cur.right);
        cur.left && stack.push(cur.left);
    }
    return res;
};

中序遍历:

// 入栈 左 -> 右
// 出栈 左 -> 中 -> 右

var inorderTraversal = function(root, res = []) {
    const stack = [];
    let cur = root;
    while(stack.length || cur) {
        if(cur) {
            stack.push(cur);
            // 左
            cur = cur.left;
        } else {
            // --> 弹出 中
            cur = stack.pop();
            res.push(cur.val); 
            // 右
            cur = cur.right;
        }
    };
    return res;
};

后序遍历:

// 入栈 左 -> 右
// 出栈 中 -> 右 -> 左 结果翻转

var postorderTraversal = function(root, res = []) {
    if (!root) return res;
    const stack = [root];
    let cur = null;
    do {
        cur = stack.pop();
        res.push(cur.val);
        cur.left && stack.push(cur.left);
        cur.right && stack.push(cur.right);
    } while(stack.length);
    return res.reverse();
};