將單鏈表的每K個節點之間逆序

　　給定一個單鏈表的頭節點head，實現一個調整鏈表的函數，使得每K 個節點之間逆序，如果最後剩下不夠K 個節點，則不調整最後幾個。

　　例如：

　　鏈表：1—>2—>3—>4—>5—>6—>7—>8—>null，k=3。

　　調整好後：3—>2—>1—>6—>5—>4—>7—>8—>null，其中7、8不調整，因為不夠一組。

　　【解析】

　　1. 首先從左到右遍歷鏈表，如果棧的大小不等於k ，則不斷的入棧

　　2. 當棧的大小等於k 時，不斷的出棧，並重新連接這些節點

　　3. 最後應該返回 newHead

package com.test;

import com.test.ListNode;

import java.util.Stack;

/**
 * Created by Demrystv.
 */
public class ReverseListNodeEveryK {

    /**
     * 使用棧的數據結構，時間復雜度是O(N)，空間復雜度是O(N)
     */
    public ListNode reverseListNodeEveryK(ListNode head, int k){
        if (k < 2){
            
 
return null;
        }
        Stack<ListNode> stack = new Stack<ListNode>();
        ListNode newHead = head;
        ListNode cur = head;
        ListNode pre = null;
        ListNode next = null;
        while (cur != null){
            next = cur.next;
            stack.push(cur);
            
 
if (stack.size() == k){
                pre = resign1(stack, pre, next);
                // 舉例說明可得證，例如k = 3
                // 如果是1 2 ，那麽不需要反轉，程序也執行不到這個if裏面來，所以返回的是 頭節點
                // 如果是1 2 3 4 ，當執行到3的時候，到了這個if裏面，這時滿足newHead==head,所以newHead就是3，符合反轉後  3 2 1 4
                // 如果是1 2 3 4 5 6 7，執行到3，newHead是3，執行到6，不滿足newHead==head,所以newHead就是newHead,就是3，符合 3 2 1 6 5 4 7
                // 真是巧妙呀！！！
                newHead = newHead == head ? cur : newHead;
            }
            cur = next;
        }
        return newHead;
    }

    private ListNode resign1(Stack<ListNode> stack, ListNode left, ListNode right){
        ListNode cur = stack.pop();
        if (left != null){
            left.next = cur;
        }
        ListNode next = null;
        while (!stack.isEmpty()){
            next = stack.pop();
            cur.next = next;
            cur = next;
        }
        // 實際傳入的這個right參數，是下一個K 範圍內的第一個節點，不屬於這個k 範圍內。
        // 確保與後面的相連
        cur.next = right;
        // 實際返回的這個cur 是這個K範圍內的最後一個節點，即下一個k 的上一個節點，即pre 的意思
        return cur;
    }
}

棧和隊列----將單鏈表的每K個節點之間逆序