反转固定区间的链表

反转一部分链表

递归思路

• 反转[left, right+1)区间内的链表，并返回新的头节点。
• 若left的前一个节点为p， 则p.next = 新的头节点。
• 但是由于p的指向，会出现一些边界需要考虑：
  • 若p初始化为head时，只有当left为3时，p才能第一次迈出去。
  • 若需要从头反转，则只能 return reverse(p, q);
  • 若是从中间开始反转，p.next = reverse(p.next, q)，此时head仍是反转后的头节点

代码

/**
 * 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} left
 * @param {number} right
 * @return {ListNode}
 */
var reverseBetween = function(head, left, right) {
    let p = head;
    let q = head;
    for(let i=1; i<left-1; i++){
        p = p.next;
    }
    for(let i=1; i<=right; i++){
        q = q.next;
    }
    // p指向left的前一个, q指向right的后一个
    if(left==1){
        let newHead = reverse(p, q);
        return newHead;
    }else{
        p.next = reverse(p.next, q);
        return head;
    }
};

// 反转[head, last), 返回新的头节点
var reverse = function(head, last){
    if(head.next == last) return head;
    let newHead = reverse(head.next, last);
    head.next.next = head;
    head.next = last;
    return newHead;
}

迭代思路

• 先遍历找到head和end，然后对"反转整个链表"略作修改。

var reverse = function(head, end){
    let pre = null;
    let curr = head;
    let nxt = curr.next;
    // 反转[head, end]即[head, end.next)区间内的链表。
    stop = end.next;
    while(curr!=stop){
        nxt = curr.next;
        curr.next = pre;
        pre = curr;
        curr = nxt;
    }
    // curr == stop
    head.next = curr;
    return pre;
}