js解leetcode(54)-简单

1.题目：删除链表的节点

题目：

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

思路：遍历节点，每次比较当前节点的next的val值，如果和目标值相同，则指向next的next
 

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} val
 * @return {ListNode}
 */
var deleteNode = function(head, val) {
  if (!head) return head;
  if (head.val == val) return head.next;
  let node = head;
  while (node.next) {
    if (node.next.val == val) {
      node.next = node.next.next;
      break;
    } else {
      node = node.next;
    }
  }
  return head;
};

2.调整数组顺序使奇数位于偶数前面

题目：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

思路：双指针，一个指针从头到尾，遇到偶数就停；一个指针从尾到头，遇到奇数就停，然后交换两个指针上的元素

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var exchange = function(nums) {
  let left = 0,
    right = nums.length - 1;
  while (left < right) {
    while (nums[left] % 2  && left < right) {
      left++;
    }
    while (nums[right] % 2 === 0 && left < right) {
      right--;
    }
    [nums[left], nums[right]] = [nums[right], nums[left]];
  }
  return nums;
};

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

题目：

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

思路：快慢指针。先让快指针走k-1个节点，然后慢指针指向第一个节点，两个指针同时开始遍历，直到快指针到最后一个节点，此时慢指针指向的就是倒数第K个节点

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
var getKthFromEnd = function(head, k) {
  let fast = head;
  let slow = head;
  while (--k) {
    fast = fast.next;
  }
  while (fast.next) {
    fast = fast.next;
    slow = slow.next;
  }
  return slow;
};

4.反转链表

题目：定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

思路：迭代和递归‘’

迭代：

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
  let pre = null;
  while (head) {
    const next = head.next;
    head.next = pre;
    pre = head;
    head = next;
  }
  return pre;
};

递归：

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head,pre=null) {
  if (!head) return pre;
  const next = head.next;
  head.next = pre;
  return reverseList(next, head);
};

5.合并两个排序链表

题目：输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

思路：迭代和递归

迭代：

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var mergeTwoLists = function(l1, l2) {
  const head = new ListNode();
  let v = head;
  while (l1 && l2) {
    if (l1.val < l2.val) {
      v.next = l1;
      l1 = l1.next;
      v = v.next;
      v.next = null;
    } else {
      v.next = l2;
      l2 = l2.next;
      v = v.next;
      v.next = null;
    }
  }
  if (!l1) {
    v.next = l2;
  } else {
    v.next = l1;
  }
  return head.next;
};

递归：

提交的代码： 18 分钟前
语言： javascript


/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var mergeTwoLists = function(l1, l2) {
  if (!l1) return l2;
  if (!l2) return l1;
  if (l1.val < l2.val) {
    l1.next = mergeTwoLists(l1.next, l2);
    return l1;
  } else {
    l2.next = mergeTwoLists(l1, l2.next);
    return l2;
  }
};