數據結構與算法 —— 鏈表linked list(04)

咱們在上篇文章裏面提到了鏈表的翻轉，給定一個鏈表，對每兩個相鄰的節點做交換，並返回頭節點，今天的這道題是它的升級版，以下：

k個一組翻轉鏈表

給出一個鏈表，每 k 個節點一組進行翻轉，並返回翻轉後的鏈表。

k 是一個正整數，它的值小於或等於鏈表的長度。若是節點總數不是 k 的整數倍，那麼將最後剩餘節點保持原有順序。

示例 :

給定這個鏈表：1->2->3->4->5

當 k = 2 時，應當返回: 2->1->4->3->5

當 k = 3 時，應當返回: 3->2->1->4->5

說明 :

• 你的算法只能使用常數的額外空間。

• 你不能只是單純的改變節點內部的值，而是須要實際的進行節點交換。

 

解題思路：

    這道題讓咱們以每K個爲一組來翻轉鏈表，其實是把原鏈表分紅若干個小段，而後對沒一個小段進行翻轉。那麼咱們就能想到他是須要兩個函數的，一個是來作分段的，一個是在對每一段作翻轉的。咱們就以題中給出的例子來看的話，1>2>3>4>5, k=3.通常在處理鏈表問題的時候，由於單向鏈表是不可逆的，只能從前日後遍歷，因此咱們通常在開頭添加一個頭結點，記錄當前最新的頭結點，值通常給爲-1,那麼新的鏈表就變爲了-1>1>2>3>4>5.k=3,那麼咱們須要把1>2>3作翻轉，作翻轉的時候咱們須要兩個指針，pre和next分別指向要被翻轉的鏈表的先後的位置，在這裏也就是pre=-1，next=4,那麼翻轉完1>2>3以後變爲-1>3>2>1>4>5,這個時候的pre指針應該是1。以下：

    

-1->1->2->3->4->5
 |           |
pre         next

-1->3->2->1->4->5
          |  |
         pre next

就這樣循環，只要循環了k個節點，就能夠調用翻轉函數來進行局部的翻轉，翻轉函數返回翻轉後的鏈表的新的pre節點，實現方法以下：

def reverseOneGroup(pre_node, next_node):
    last_node = pre_node.next
    cur_node = last_node.next
    while cur_node != next_node:
        last_node.next = cur_node.next
        cur_node.next = pre_node.next
        pre_node.next = cur_node
        cur_node = last_node.next

    return last_node

　　

在翻轉函數中，定義兩個三個指針，一個是pre指針，一個是last指針，一個是cur指針，pre指針是鏈表的頭指針，cur指針是目前循環到的節點指針，last指針是當前循環到指針cur的前置節點指針，每次翻轉cur的時間，只須要把last的next指向cur的next，cur的next指向pre的next，pre的next指向cur就好，而後cur就迭代下一個node，爲last的next指針。整體的實現代碼以下：

 

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None


def reverseOneGroup(pre_node, next_node):
    last_node = pre_node.next
    cur_node = last_node.next
    while cur_node != next_node:
        last_node.next = cur_node.next
        cur_node.next = pre_node.next
        pre_node.next = cur_node
        cur_node = last_node.next

    return last_node


class Solution(object):
    def reverseKGroup(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        if k == 1 or not head:
            return head
        dump = ListNode(-1)
        dump.next = head
        pre = dump
        cur = head
        i = 0
        while cur:
            i += 1
            if i % k == 0:
                pre = reverseOneGroup(pre, cur.next)
                cur = pre.next
            else:
                cur = cur.next

        return dump.next

　　

個人這個實現方法應該是我能想到的最常規，最簡單的算法，確定會有其餘的算法實現，你們能夠探討一下，好比在一個函數裏實現，好比像上一篇文章同樣使用遞歸，你們能夠一塊兒交流，歡迎給我留言，交流。

coding交流羣：226704167，，鄭州程序員羣：59236263願和各位一塊兒進步！

微信公衆號：