2道链表反转leetcode25_234

25. Reverse Nodes in k-Group

给一个链表和一个k，每k个结点反转一次，最后一组如果没有k个就不反转了
Given this linked list: 1->2->3->4->5
For k = 2, you should return: 2->1->4->3->5
For k = 3, you should return: 3->2->1->4->5

1. 先遍历一遍找链表长度len
2. 之后每k个结点一循环，进行反转，反转时每次要记住一个新的头结点，反转完成后将len-k
3. 如果剩余的len < k 则反转结束

public ListNode reverseKGroup(ListNode head, int k) {
    if (head == null) return null;
    int len = 0;
    for (ListNode i = head; i != null; i = i.next){
        len++;
    }

    ListNode tail = head;
    ListNode newhead = new ListNode(0);
    newhead.next = head;
    ListNode everyhead = newhead; //每组的头结点

    while (tail != null && len >= k) {
        for (int i = 1; i < k; i++) {
            ListNode p = tail.next;
            ListNode last = p.next;
            tail.next = last;
            p.next = everyhead.next;
            everyhead.next = p;
        }
        len -= k;
        everyhead = tail; //每组循环结束后，将该组最后一个结点设为下一组的头结点
        tail = tail.next;
    }
    return newhead;
}

234. Palindrome Linked List

判断一个链表是否是回文结构

1. 设置3个结点，都指向头
2. 其中一个每次走1步，一个每次走2步，遍历一遍可以找到中点
3. 所以现在有一个指向头的指针和一个指向中点的指针，之后有两种解法
4. 第一种就是直接将其中一个链表反转，再和另一个链表一一对比即可。这种方法虽然空间复杂度是O(1)，但会破坏链表结构
5. 第二种方法用递归，将指向中点的指针递归到链表尾端，然后递归的和指向头结点的链表比较。这种方法不会破坏链表结构，但空间复杂度是O(n)，代码是这种方法

时间复杂度都是O(n)

ListNode first = null;
public boolean isPalindrome(ListNode head) {
     if (head == null || head.next == null) return true;

     ListNode second = head, last = head;
     first = head;
     while (last != null && last.next != null) {
         second = second.next;
         last = last.next.next;
     }

     //last不为空说明长度是奇数，second在中点，所以前进一个
     if (last != null) second = second.next;

     return isSame(second);
}

public boolean isSame(ListNode second) {
     boolean mark = true;
     if (second != null) {
         mark = isSame(second.next) && (first.val == second.val);
         first = first.next;
     }
     return mark;
}