牛客高频Top200(5)

NC50链表每k个节点一组翻转

• 当k = 1或者传入链表为空时，k可以直接返回。
• 数组stack用来模拟栈，将当前节点放入stack中
• 当stack中的元素个数达到k个时，从栈顶取出
• 记得取出的元素next一定要设置为null，要不然如果链表长度和k值相等就会陷入一个圈套啦！（可以输入{1,2}，2试一试），然后放在新的newHead后面，使用尾插法。
• 当遍历完整个链表时，若stack数组中还有剩余，这部分就不需要逆序了，直接使用shift方法按顺序依次取出放在新链表后面。
• 最后返回newHead.next就好了。

/*
 * function ListNode(x){
 *   this.val = x;
 *   this.next = null;
 * }
 */

/**
  * 
  * @param head ListNode类 
  * @param k int整型 
  * @return ListNode类
  */
function reverseKGroup( head ,  k ) {
    if(k <= 1 || !head) return head;
    let newHead = new ListNode(-1);
    let rear = null;//指向新链表的尾部
    let stack = [];
    let p = head;
    while(p){
        let cur = p;
        p = p.next;
        stack.push(cur);
        if(stack.length == k){
            while(stack.length){
                if(newHead.next == null){
                    let top = stack.pop();
                    top.next = null;
                    newHead.next = top;
                    rear = top;
                }else{
                    let top = stack.pop();
                    top.next = null;
                    rear.next = top;
                    rear = top;
                }
            }
        }
    }
    if(stack.length != 0){
        while(stack.length){
            if(newHead.next == null){
                    let top = stack.shift();
                    top.next = null;
                    newHead.next = top;
                    rear = top;
                }else{
                    let top = stack.shift();
                    top.next = null;
                    rear.next = top;
                    rear = top;
                }
        }
    }
    
    return newHead.next;
    
}
module.exports = {
    reverseKGroup : reverseKGroup
};

NC91 最长上升子序列(三)

法一：动态规划

• 遍历，当到第i个时，遍历之前的0~i，当arr[i]>arr[j]时，更新res，找到最大的res，dp[i] = res+ 1；
• 最后逆序查找对应的数组元素，加入ans数组，最后返回ans数组即可。

/**
 * retrun the longest increasing subsequence
 * @param arr int整型一维数组 the array
 * @return int整型一维数组
 */
function LIS( arr ) {
    let dp = new Array(arr.length);
    dp.fill(1);
    let max = 0;
    for(let i = 1 ; i < arr.length ; i ++){
        let res = 0;//记录前i个中比dp[i]小的最大dp值
        for(let j = 0 ; j < i ; j++){
            if(arr[i] > arr[j]){
                res = Math.max(res , dp[j]);
            }
        }
        dp[i] = res + 1;
        max = Math.max(max , dp[i]);
    }
    let ans = []
    for(let t = arr.length - 1 ; t >= 0 ;t--){
        if(dp[t] == max){
            ans.unshift(arr[t]);
            max--;
        }
    }
    return ans;
}
module.exports = {
    LIS : LIS
};

法二：动态规划 + 二分
看题解写的代码

/**
 * retrun the longest increasing subsequence
 * @param arr int整型一维数组 the array
 * @return int整型一维数组
 */
function LIS( arr ) {
    let d = new Array(arr.length + 1);//  d[i] 代表长度为i的字序列末尾数字的最小值
    let p = new Array(arr.length);//  p[i] 代表当前值对应d值
    let len = 1;//当前最长上升子序列的长度
    d[0] = -1;
    d[1] = arr[0]
    p[0] = 1;
    for(let i = 1 ; i < arr.length ; i++){
        if(arr[i] > d[len]){
            //添加到d数组末尾  更新len 找到当前对应的长度 d值
            len++;
            d[len] = arr[i];
            p[i] = len;
        }else{
            //通过二分找到第一个大于等于目标值的位置 替换
            let left = 1 ;
            let right = len;
            let index = 0;
            while(left <= right){
                let mid = Math.floor((left + right) / 2);
                if(d[mid] < arr[i]){
                    index = mid;
                    left = mid + 1;
                }else{
                    right = mid - 1;
                }
            }
            d[index + 1] = arr[i];
            p[i] = index + 1;
        }
    }
    let ans = [];
    for(let j = arr.length -1 ; j >= 0 ;j --){
        if(p[j] == len){
            ans.unshift(arr[j]);
            len -- ;
        }
    }
    return ans;
}
module.exports = {
    LIS : LIS
};

NC62 判断是不是平衡二叉树

• ans开始置为true 空树直接返回true
• 非空就深度遍历
• l为左子树深度 r为右子树深度
• l与r的差值超过1 ans则为false
• 返回ans

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function IsBalanced_Solution(pRoot)
{
    if(!pRoot) return true;
    let ans = true;
    function dfs(node){
        if(node == null) return 0;
        let l = dfs(node.left);
        let r = dfs(node.right);
        if(l - r > 1 || l - r < -1){
            ans = false;
        }
        return Math.max(l,r) + 1;
    }
    dfs(pRoot);
    return ans;
}
module.exports = {
    IsBalanced_Solution : IsBalanced_Solution
};

NC13 二叉树的最大深度

深度遍历找到最大深度

/*
 * function TreeNode(x) {
 *   this.val = x;
 *   this.left = null;
 *   this.right = null;
 * }
 */

/**
  * 
  * @param root TreeNode类 
  * @return int整型
  */
function maxDepth( root ) {
    let max = 0;
    function dfs(node , depth){
        if(node.left == null && node.right == null){
            max = Math.max(depth , max);
            return;
        }
        if(node.left != null) dfs(node.left , depth + 1);
        if(node.right != null) dfs(node.right , depth + 1);
    }
    if(!root) return 0;
    dfs(root , 1);
    return max;
}
module.exports = {
    maxDepth : maxDepth
};