力扣刷题

面试题 02.02. 返回倒数第 k 个节点

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} k
 * @return {number}
 */
var kthToLast = function(head, k) {
      // 判断边际
      if(head === null || k<= 0) return null
      
      // 定义双指针
      let fast = head
      let slow = head
      
      // fast先移动k步
      for (let i = 0; i < k; i++) {
        // 如果fast为null表示移出链表
        if(fast === null) return null
        fast = fast.next
      }
      
      // 双指针同时移动知道fast移出链表
      while(fast!==null){
          fast = fast.next
          slow = slow.next
      }
      
      return slow.val
};

[445. 两数相加 II]

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
    l1 = reverseList(l1); // 逆转第一个链表
    l2 = reverseList(l2); // 逆转第二个链表
    
    let carry = 0;
    let dummyHead = new ListNode(0);
    let current = dummyHead;

    // 同时遍历两个链表，计算每一位的和
    while (l1 !== null || l2 !== null) {
        let sum = carry;
        if (l1 !== null) {
            sum += l1.val;
            l1 = l1.next;
        }
        if (l2 !== null) {
            sum += l2.val;
            l2 = l2.next;
        }

        // 更新 carry 和当前结果节点
        carry = Math.floor(sum / 10);
        current.next = new ListNode(sum % 10);
        current = current.next;
    }

    // 如果有进位，添加一个新的节点
    if (carry > 0) {
        current.next = new ListNode(carry);
    }

    // 再次反转结果链表，使得高位在前
    return reverseList(dummyHead.next);
};

// 反转链表
function reverseList(head) {
    let prev = null;
    let current = head;
    while (current !== null) {
        let nextNode = current.next;
        current.next = prev;
        prev = current;
        current = nextNode;
    }
    return prev;
}

105. 从前序与中序遍历序列构造二叉树

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {number[]} preorder
 * @param {number[]} inorder
 * @return {TreeNode}
 */
var buildTree = function (preorder, inorder) {

    // 不存在直接返回null
    if (!preorder.length || !inorder.length) return null

    // 前序遍历的第一个元素是根节点
    let rootVal = preorder[0]
    let root = new TreeNode(rootVal)

    // 在中序遍历中找到根节点的位置
    let rootIndexInorder = inorder.indexOf(rootVal)

    // 构建左子树
    let leftPreorder = preorder.slice(1, rootIndexInorder + 1)
    let leftInorder = inorder.slice(0, rootIndexInorder)
    root.left = buildTree(leftPreorder, leftInorder)

    // 构建右子树
    let rightPreorder = preorder.slice(rootIndexInorder + 1)
    let rightInorder = inorder.slice(rootIndexInorder + 1)
    root.right = buildTree(rightPreorder, rightInorder)

    return root
};