如何在Python中反转循环链表

我有一个循环链表对象，我正在练习，我被困在了必须反转循环链表的地方。我可以找到很多使用Java&C的示例，但没有python示例。我试图转换C和Java程序的逻辑，但结果不正确。它只收集了列表的一部分，似乎提前终止

以下是我迄今为止定义

节点和
循环列表
对象的代码：

class Node(object):

    def __init__(self, data = None, next_node = None):
        self.data = data
        self.next_node = next_node


class CircularLinkedList(object):

    def __init__(self, head = None, end = None):
        self.head = head
        self.end = end

    def traverse(self):

        curr_node = self.head

        while curr_node.next_node:            
            print(curr_node.data)            
            curr_node = curr_node.next_node

            if curr_node == self.head:
                break


    def insert_end(self, data):

        new_node = Node(data) 

        # handle empty list case
        if self.head == None:            
            self.head = new_node
            self.head.next_node = new_node
            self.end = new_node
            return

        # handle non-empty list case
        if self.end != None:
            self.end.next_node = new_node
            new_node.next_node = self.head        
            self.end = new_node
            return


    def insert_beg(self, data):

        new_node = Node(data)
        new_node.next_node = self.head        
        curr_node = self.head

        # handle empty list case
        if curr_node == None:            
            self.head = new_node
            self.end = new_node
            self.head.next_node = new_node
            return

        # handle non-empty list case
        if self.end != None:
            self.end.next_node = new_node
            new_node.next_node = self.head        
            self.head = new_node
            return

    def insert_mid(self, ref_node, data):

        # handle empty node case
        if ref_node == None:
            print("You've selected an empty node.")

        # if we are inserting after the end node, then just use the insert_end method
        if ref_node == self.end:
            self.insert_end(data)
            return

        # otherwise it's a true mid.
        new_node = Node(data)            
        ref_next = ref_node.next_node        
        ref_node.next_node = new_node
        new_node.next_node = ref_next


    def delete_beg(self):

        if self.head != None:            
            aft_head = self.head.next_node
            self.end.next_node = aft_head
            self.head = aft_head
        else:
            print('The list is empty, no values to delete.')

    def delete_end(self):

        if self.end != None:

            curr_node = self.head

            while curr_node.next_node.next_node != self.head:                        
                curr_node = curr_node.next_node


            self.end = curr_node
            curr_node.next_node = self.head

    def delete_mid(self, position):

        if position == 0:            
            self.delete_beg()
            return

        if position == self.list_size():
            self.delete_end()
            return


        curr_node = self.head.next_node
        count = 0

        while count <= position:            
            count = count + 1 
            curr_node = curr_node.next_node

        curr_node.next_node = curr_node.next_node.next_node


    def list_size(self):

        curr_node = self.head

        count = 0

        while curr_node.next_node:            
            count = count + 1            
            curr_node = curr_node.next_node            
            if curr_node == self.head:
                break

        return count

以下是我的代码的主要部分，其中插入和删除值，然后尝试反转列表：

# define a new list
circular_list = CircularLinkedList()

# insert a few values at the end
circular_list.insert_end(50)
circular_list.insert_end(60)
circular_list.insert_end(70)

# insert a few values at the beginning
circular_list.insert_beg(90)
circular_list.insert_beg(100)

# grab a node
first_node = circular_list.end

# insert value inbetween two nodes.
circular_list.insert_mid(first_node,20)

# delete the first and last value
circular_list.delete_beg()
circular_list.delete_end()

print('Before Reversal')
print('-'*20)
circular_list.traverse()

circular_list.reverse()

print('After Reversal')
print('-'*20)
circular_list.traverse()

但当我尝试反转时，这是输出：

def reverse(self):

    if self.head == None:
        return

    last = self.head
    prev = self.head
    curr = self.head.next_node

    while self.head != last:

        self.head = self.head.next_node
        curr.next_node = prev
        prev = curr
        curr = self.head

    curr.next_node = prev
    self.head = prev

Before Reversal
--------------------
90
50
60
70
After Reversal
--------------------
90
50

通过查看您的代码，reverse（）函数肯定有一个bug。
您可以很容易地看到，您从未开始while循环迭代，因为条件在开始时为false。我会这样做：

def reverse(self):

    if self.head == None:
        return

    last = self.head
    curr = self.head
    prev = self.end
    next=curr.next_node
    curr.next_node = prev
    prev = curr
    curr = next
    while curr != last:
        next=curr.next_node
        curr.next_node = prev
        prev = curr
        curr = next

在
反向
中，
while
循环中的条件永远无法满足，因为您刚刚将
上次
初始化为等于
self.head
。这意味着循环体永远不会运行，因此您只需要处理几个节点，而不是整个列表。是否应该将
last
初始化为
self.end
呢？因此，如果我将
last
更改为
self.end
我会得到一个永不终止的无限循环。这对我来说没有意义，因为如果我在
while
循环中重新分配
self.head
，它最终应该等于最后一个节点。正如@Bickknght已经指出的，所有这些操作都是将第二个节点链接回第一个节点。我不清楚你的算法——你在圆圈周围迭代
head
，而'last'没有改变（迭代的最后一个元素？）。你的代码工作得很好，我唯一添加的是
curr.next_node=prev
和
self.head=prev
，最后它重新分配了head节点。