Apakah kaedah penyongsangan senarai pautan python

Pembalikan senarai terpaut ular sawa

Senarai terpaut terbalik

Saya berikan anda kepala nod kepala senarai pautan tunggal, sila balikkan senarai terpaut dan kembalikan senarai pautan terbalik.

• Input: kepala = [1,2,3,4,5]

• Output: [5,4,3,2,1]

• Input: kepala = [1,2]

• Output: [2,1]

Contoh 3:

• Input : head = []

• Output: []

Penyelesaian

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    """
    解题思路：
    1.新建一个头指针
    2.遍历head链表，依次在新的头节点位置插入，达到反转的效果
    """
    def reverseList(self, head: ListNode) -> ListNode:
        # 循环
        new_head = None

        while head:
            per = head.next # pre 为后置节点，及当前节点的下一个节点

            head.next = new_head # 插入头节点元素

            new_head = head # 把串起来的链表赋值给头指针

            head = per  # 向后移一个单位
        
        return  new_head  # 返回一个新的链表

Kemahiran berkaitan senarai terpaut pembalikan Python

Memandangkan kepala nod pHead senarai terpaut tunggal (nod kepala mempunyai nilai, contohnya, dalam rajah di bawah, valnya ialah 1) dengan panjang n, selepas membalikkan senarai terpaut, kembalikan kepala senarai pautan baharu.

Keperluan: kerumitan ruang O(1)O(1), kerumitan masa O(n)O(n).

Input:

{1,2,3}

Nilai pulangan:

{3,2,1}

Mari kita lihat kod senarai pautan terbalik yang paling asas:

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        cur = pHead
        pre = None
        while cur:
            nextNode = cur.next
            cur.next = pre
            pre = cur
            cur = nextNode
        return pre

Formula utama

Tangkap beberapa Perkara utama:

• kur: nod kepala senarai terpaut asal Pada penghujung penyongsangan, cur menunjuk ke nod pra

• .

  pra: Nod ekor senarai terpaut asal ialah nod kepala senarai terpaut terbalik. Pulangan terakhir adalah pra.

• sementara cur: Mewakili syarat untuk membalikkan gelung, di sini adalah untuk menentukan sama ada cur kosong. Anda juga boleh menukar syarat soalan kepada keadaan gelung lain

• untuk membalikkan nod ekor senarai terpaut Nod ekor di sini ialah Tiada, dan spesifikasi eksplisit akan disebut kemudian.

Untuk masalah membalikkan senarai terpaut, fahami peranan utama nod kepala senarai terpaut asal, nod ekor senarai terpaut asal, keadaan gelung terbalik dan nod ekor senarai terbalik pada asasnya tiada masalah.

Seterusnya, mari berikan dua contoh:

Menterbalikkan selang yang ditentukan dalam senarai terpaut

Menyongsangkan setiap nod k dalam senarai terpaut

Terbalikkan selang yang ditentukan dalam senarai terpaut

Terbalikkan selang antara kedudukan m dan kedudukan n dalam senarai terpaut dengan bilangan nod, memerlukan kerumitan masa O(n) dan kerumitan ruang O( 1).

Keperluan: kerumitan masa O(n), kerumitan ruang O(n)

Lanjutan: kerumitan masa O(n), kerumitan ruang O (1)

Input:

{1,2,3,4,5},2,4

Nilai pulangan:

{1,4,3,2,5}

Gunakan formula

Perbezaan antara soalan ini dan garis dasar ialah Tukar pembalikan keseluruhan senarai terpaut kepada pembalikan selang antara kedudukan m dan kedudukan n senarai terpaut Mari kita gunakan formula:

• Nod kepala senarai terpaut asal: cur. : bermula dari kepala , kemudian ambil langkah m-1 untuk mencapai cur

• Nod ekor senarai terpaut asal: pra: Nod di hadapan cur

• Keadaan gelung terbalik : untuk i dalam julat(n,m)

• Terbalikkan nod ekor senarai terpaut: anda perlu menyimpannya dan mulakan dari kepala, kemudian pergi m-1 langkah, apabila anda mencapai cur, pada masa ini pra kedudukan prePos. prePos.next ialah nod ekor senarai terpaut terbalik

Berbanding dengan yang sebelumnya, anda perlu memberi perhatian tambahan:

• . perlu disimpan dan dimulakan dari kepala , ambil langkah m-1 semula, dan apabila anda mencapai cur, kedudukan pra pada masa ini adalah prePos. Selepas kitaran pembalikan tamat, pergi melalui benang

• Memandangkan keseluruhan senarai yang dipautkan tidak diterbalikkan, adalah lebih baik untuk mencipta dummyNode nod kepala maya baharu dan dummyNode.next menghala ke keseluruhan senarai terpaut

Pelaksanaan kod

Pertama lihat kod bahagian formula:

# 找到pre和cur
i = 1
while i<m:
    pre = cur
    cur = cur.next
    i = i+1
 
# 在指定区间内反转
preHead = pre
while i<=n:
    nextNode = cur.next
    cur.next = pre
    pre = cur
    cur = nextNode
    i = i+1

Membenang jarum dan bahagian benang kod:

nextNode = preHead.next
preHead.next = pre
if nextNode:
    nextNode.next = cur

Kod penuh:

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
 
class Solution:
    def reverseBetween(self , head , m , n ):
        # write code here
        dummpyNode = ListNode(-1)
        dummpyNode.next = head
        pre = dummpyNode
        cur = head
 
        i = 1
        while i<m:
            pre = cur
            cur = cur.next
            i = i+1
 
        preHead = pre
        while i<=n:
            nextNode = cur.next
            cur.next = pre
            pre = cur
            cur = nextNode
            i = i+1
        
        nextNode = preHead.next
        preHead.next = pre
        if nextNode:
            nextNode.next = cur
 
        return dummpyNode.next

Terbalikkan nod dalam senarai terpaut setiap kumpulan k

Terbalikkan nod dalam senarai terpaut yang diberikan setiap kumpulan k dan kembalikan flip Senarai terpaut akhir

Jika bilangan nod dalam senarai terpaut bukan gandaan k, biarkan nod terakhir yang tinggal seperti sedia ada

Anda tidak boleh menukar nilai dalam nod, hanya nod itu sendiri.

memerlukan kerumitan ruang O(1) dan kerumitan masa O(n)

Input:

{1,2, 3, 4,5},2

Nilai pulangan:

{2,1,4,3,5}

Gunakan formula

Perbezaan antara soalan ini dan garis dasar ialah penyongsangan keseluruhan senarai terpaut ditukar kepada kumpulan penyongsangan k. Jika bilangan nod bukan gandaan k. baki Nod kekal seperti sedia ada.

Mari kita lihat dalam bahagian dahulu Katakan kita menghadapi senarai terpaut dari kedudukan 1 ke kedudukan k:

• Nod kepala senarai terpaut asal: cur: mulakan dari kepala dan pergi k -1 langkah untuk mencapai cur

• 原链表的尾节点：pre：cur前面的节点

• 反转循环条件：for i in range(1,k)

• 反转链表的尾节点：先定义tail=head，等反转完后tail.next就是反转链表的尾节点

先看下套公式部分的代码：

pre = None
cur = head
tail = head
 
 
i = 1
while i<=k:
    nextNode = cur.next
    cur.next = pre
    pre = cur
    cur = nextNode
    i = i+1

这样，我们就得到了1 位置1-位置k的反转链表。

此时：

• pre：指向反转链表的头节点

• cur：位置k+1的节点，下一段链表的头节点

• tail：反转链表的尾节点

那么，得到位置k+1-位置2k的反转链表，就可以用递归的思路，用tail.next=reverse(cur，k)

需要注意：如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样

i = 1
tmp = cur
while i<=k:
    if tmp:
        tmp = tmp.next
    else:
        return head
    i = i+1

代码实现

完整代码：

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
 
class Solution:
    def reverseKGroup(self , head , k ):
       
        # write code here
        return self.reverse(head, k )
    
    def reverse(self , head , k ):
        pre = None
        cur = head
        tail = head
 
        i = 1
        tmp = cur
        while i<=k:
            if tmp:
                tmp = tmp.next
            else:
                return head
            i = i+1
        
        i = 1
        while i<=k:
            nextNode = cur.next
            cur.next = pre
            pre = cur
            cur = nextNode
            i = i+1
 
        tail.next = self.reverse(cur, k)
        return pre

好了，抓住几个关键点：

• cur：原链表的头节点，在反转结束时，cur指向pre的下一个节点

• pre：原链表的尾节点，也就是反转后链表的头节点。最终返回的是pre。

• while cur：表示反转循环的条件，这里是判断cur是否为空。也可以根据题目的条件改成其他循环条件

• 反转链表的尾节点，这里的尾节点是None，后面会提到显式指定。

Atas ialah kandungan terperinci Apakah kaedah penyongsangan senarai pautan python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!