【算法训练】链表反转相关

一、K个一组反转链表 25

1、分析

首先将问题分解成为两部分，首先是对长度为k的链表部分的反转，其次是递归的形式依次对整个链表中的k个一组的链表进行反转并连接在一起。

对于递归的base case ，可以看出是当长度不大于k时，直接原顺序返回即可。具体可见代码的注释。

2、代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseab(self,a,b):  #反转a，b之间的链表，左闭右开区间
        pre = None
        cur,nxt = a,a
        while cur!=b:
            nxt = cur.next
            cur.next = pre
            pre = cur
            cur = nxt
        return pre
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        a,b = head,head
        for _ in range(k):  #base case，不大于k的时候按原来的顺序返回
            if not b:  #说明长度不大于k
                return head
            b = b.next
        newHead = self.reverseab(a,b)  #对k个一组链表进行反转
        a.next = self.reverseKGroup(b,k) #递归对下一个k个一组的链表进行反转
        return newHead

js

/**
 * 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 {ListNode}
 */
var reverseKGroup = function(head, k) {
    let a=head,b = head;
    for(let i=0;i<k;i++){
        if(b===null){
            return head;
        }
        b = b.next;
    }
    let newHead = reverseab(a,b);
    a.next = reverseKGroup(b,k);
    return newHead;

};

var reverseab = function(a,b){
    let pre = null;
    let cur = a,nxt = a;
    while(cur !== b){
        nxt = cur.next;
        cur.next = pre;
        pre = cur;
        cur = nxt;
    }
    return pre;
}

二、回文链表 234

1、分析

首先通过快慢指针找到链表的中间节点，然后对后半部分进行链表的反转。之后再依次比较前后链表指针的值即可。
在找中间节点的时候注意一个点，就是如果链表的长度是奇数的话，快慢指针遍历完之后，还需要继续将slow指针后移一位，若为整个链表长度为偶数的话，就不需要进行此操作。
具体见代码及注释。

2、代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reveren(self,a):  #用于反转链表
        pre = None
        cur,nxt = a,a
        while cur:
            nxt = cur.next
            cur.next = pre
            pre = cur
            cur = nxt
        return pre
    def isPalindrome(self, head: ListNode) -> bool:
        slow,fast = head,head
        while fast and fast.next: #快慢指针寻找链表的中间节点
            slow = slow.next
            fast = fast.next.next
        if fast: #若fast不为空，证明链表的长度为奇数，所以slow还要继续后移一位
            slow = slow.next
        left,right = head,self.reveren(slow) #采用双指针，分别指向前半部分链表，以及反转后的后半部分链表
        while right: #双指针遍历比较，若一旦出现值不相等，就返回false
            if left.val != right.val:
                return False
            left = left.next
            right = right.next
        return True

js

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {boolean}
 */
var isPalindrome = function(head) {
    let fast=head,slow=head;
    while(fast!==null && fast.next !== null){
        slow = slow.next;
        fast = fast.next.next;
    }
    if(fast!==null){
        slow = slow.next;
    }
    let left=head,right = reverseN(slow);
    while(right!==null){
        if(left.val != right.val){
            return false;
        }
        left = left.next;
        right = right.next;
    }
    return true;

};
var reverseN = function(a){
    let pre = null,cur = a,nxt = a;
    while(cur !== null){
        nxt = cur.next;
        cur.next = pre;
        pre  = cur;
        cur = nxt;
    }
    return pre;
}