链表算法练习

1、206-单链表反转

思路1:在链表上直接反转，只是需要一个节点存储剩余部分的链表指针

时间复杂度：O(n) 空间复杂度：O(1)

const listNode = (val,next) =>{
  this.val = val;
  this.next = next;
}

const reverseList = (head) =>{
  if(!head || !head.next) return head;
  let newHead = head,cur = head.next;
  while(cur){
    const next = cur.next;
    cur.next = newHead;
    newHead = cur;
    cur = next;
  }
  return newHead;
} 

思路2:用一个新的链表存储

const listNode = (val,next) =>{
  this.val = val;
  this.next = next;
}

const reverseList = (head) =>{
  if(!head || !head.next) return head;
  let newHead = null,cur = head,p = head.next;
  while(cur){
    cur.next = newhead;
    cur = p;
    p=p.next;
  }
  return newHead;
} 

思路3:迭代，迭代主要思考的是第一次以及最后一次调用，中间行为是循环重复行为。

思考如果在最后一个节点时（head.next === null)返回head后，应该将最后一个指针的指向反转

o<-o<-…o<-【o】->o->o…->o->o

const listNode = (val,next) =>{
  this.val = val;
  this.next = next;
}

const reverseList = (head) =>{
  if(!head || !head.next) return head;
  let newHead = reverseList(head.next);
  head.next.next = head; // * 从最后一个开始分析。 kn-1的next = kn,kn的next重新指向，则链表当场反转
  head.next = null; // 反转完后，假设是最边缘节点k1，k1的next必须为null，kn-1也是一样的，这样返回的head才是一个反向的完整链表。
  return newHead;
}

---

2、141-环的检测

1、快慢指针，如果是环形，快指针跑两圈就能碰上慢指针

2、标记法。遍历链表，给每个节点对象设置标记flag=true，如果下一次遇到flag=true则直接结束循环返回true。

function hasCycle (head) {
  if(!head || head.next === null) return false;
  let fast = head,slow = head;
  while(fast && fast.next) {
    fast = fast.next.next;
    slow = slow.next;
    if(fast === slow){
      return true;
    }
  }

  return false
}

3、非常规解法 JSON.stringify当在循环引用时会抛出异常TypeError (“cyclic object value”)（循环对象值）

var hasCycle = function(head) {
  try {
      JSON.stringify(head)
      return false
  } catch {
      return true
  }
};

---

3、21-两个有序链表合并

1、设置一个新的头节点和尾部指针cur，list1 / list2作为两个遍历指针，判断当前节点大小，然后把整个链表轮流接到新的链表后。

const mergeTwoLists = function(list1, list2) {
  if(!list1 || !list2) return list1 ? list1 : list2;
  let newHead = new ListNode(-1),cur=newHead;
  while(list1 && list2) {
    if(list1.val < list2.val){
      cur.next = list1;
      list1 = list1.next;
    }else{
      cur.next = list2;
      list2 = list2.next
    }

    cur = cur.next;
  }

  cur.next = list1 ? list1 : list2;
  return newHead.next;
}

2、由于合并操作是循环有序的操作，可以使用递归调用来节省while。

分析每一次的重复行为：判断l1/l2节点大小，然后把还无序（需要重复判断）的链表接到小的那个后面。

终止条件：一方为空为止，然后直接返回另一方。

const mergeTwoLists = function(list1, list2) {
  if(!list1 || !list2) return list1 ? list1 : list2;

  if(list1.val <list2.val){
    list1.next = mergeTwoLists(list1.next,list2);
    return list1;
  }else{
    list2.next = mergeTwoLists(list1,list2.next);
    return list2;
  }
}

---

4、19-删除链表倒数第n个节点

双指针判断倒数第n个，注意慢指针需要停留在倒数第n-1个节点上才能删除，也就是说循环n+1次后慢指针才开始动。注：快指针走到null的时候是刚好n节点。

删除的节点刚好是head时候很麻烦，所以可以先创建一个空的头节点在head前面。

const removeNthFromEnd = function(head, n) {
  let newHead = new ListNode(-1,head);
  let fast=newHead,slow=newHead;

  while(n--){
    fast = fast.next;
  }

  if(!fast || !fast.next) return slow.next;

  while(fast.next){
    slow = slow.next;
    fast = fast.next;
  }

  slow.next = slow.next.next;

  return newHead.next;
}

---

5、876-求链表的中间节点

双数链表取中间偏后，单数取中间。双指针即可

var middleNode = function(head) {
  let fast = head,slow = head;
  if(!head || !head.next) return head;
  while(fast && fast.next){
    fast = fast.next.next;
    slow = slow.next;
  }

  return slow;
};

链表的题

将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。
例如：
给出的链表为 1\to 2 \to 3 \to 4 \to 5 \to NULL1→2→3→4→5→NULL, m=2,n=4m=2,n=4,
返回 1\to 4\to 3\to 2\to 5\to NULL1→4→3→2→5→NULL.

数据范围： 链表长度 0 < size \le 10000<size≤1000，0 < m \le n \le size0<m≤n≤size，链表中每个节点的值满足 |val| \le 1000∣val∣≤1000
要求：时间复杂度 O(n)O(n) ，空间复杂度 O(n)O(n)
进阶：时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)

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

/**
 *
 * @param head ListNode类
 * @param m int整型
 * @param n int整型
 * @return ListNode类
 */
function reverseBetween(head, m, n) {
  if (m >= n || !head || !head.next) return head;
  let start = head;
  let end = head;

  // 指针指向前一个
  for (let i = 1; i <= n; i++) {
    if (i < m - 1) start = start.next;
    end = end.next;
  }

  let cur = m === 1 ? start : start.next; // 翻转链表的当前节点，当翻转首节点是1时，cur=start，这样才能把start的节点放在pre的末尾参与翻转，因为m为1时，m+1没有节点。
  let pre = null; // 翻转的链表

  while (cur !== end) {
    let next = cur.next;
    cur.next = pre;
    pre = cur;
    cur = next;
  }
  if (m === 1) {
    // cur=start而不是start.next,所以start.next === null；
    head.next = end;
    head = pre;
  } else {
    start.next.next = end; // start的next装的是目前pre末尾的节点
    start.next = pre;
  }

  return head;
}
module.exports = {
  reverseBetween: reverseBetween,
};

---

描述
将给出的链表中的节点每 k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。

数据范围： \ 0 \le n \le 2000 0≤n≤2000 ， 1 \le k \le 20001≤k≤2000 ，链表中每个元素都满足 0 \le val \le 10000≤val≤1000
要求空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)
例如：
给定的链表是 1\to2\to3\to4\to51→2→3→4→5
对于 k = 2k=2 , 你应该返回 2\to 1\to 4\to 3\to 52→1→4→3→5
对于 k = 3k=3 , 你应该返回 3\to2 \to1 \to 4\to 53→2→1→4→5

// k个为一组，应该想到是递归。同时注意结束节点的判定。
function reverseKGroup( head ,  k ) {
    if(!head || !head.next) return head;
    let cur = head;
    let pre = null;
    let node = head;// 下一个要开始的节点end
    for(let i=0;i<k;i++){
        if(!node) return head;// if判断是否为空要在遍历之前，不然k=剩余节点的时候node = node.next,node === null直接退出循环,但是此时应该要翻转
        node = node.next;
    }
    
    while(cur !== node){
        let next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    
    head.next = reverseKGroup(node,k);
    return pre;
}
module.exports = {
    reverseKGroup : reverseKGroup
};