问题描述
我们的任务是执行以下代码。
给定一个包含 N 个整数的链表。您将对列表执行以下反向操作：
选择列表中仅包含偶数的所有子部分。例如，如果列表为 {1,2,8,9,12,16}，则所选子部分将为 {2,8},{12,16}。
反转选定的子部分，例如 {8,2} 和 {16,12}。
列表现在应该是 {1,16,12}。
问题是它没有创建子列表并给我输出像 [2,16]，但我想要它像 {2,16}。
下面是我的代码：
class Node:
def __init__(self,data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None
self.tail = None
def append_value(self,x):
if not isinstance(x,Node):
x = Node(x)
if self.head is None:
self.head = x
else:
self.tail.next = x
self.tail = x
def reverse_list_recursive(self,current,prevIoUs):
if self.head is None:
return
elif current.next is None:
self.tail = self.head
current.next = prevIoUs
self.head = current
else:
next = current.next
current.next = prevIoUs
self.reverse_list_recursive(next,current)
def is_empty(self):
return self.head is None
def __str__(self):
to_print = ''
current = self.head
while current:
to_print += f'{current.data}->'
current = current.next
if to_print:
return f'[{to_print[:-2]}]'
return '[]'
这是我的功能：
def reverse_sub_parts(self):
sublist_list = list()
current = self.head
while current:
if current.data % 2 == 0:
sublist_list.append(current.data)
current = current.next
print(sublist_list)
my_list = LinkedList()
my_list.append_value(1)
my_list.append_value(2)
my_list.append_value(8)
my_list.append_value(9)
my_list.append_value(12)
my_list.append_value(16)
my_list.reverse_sub_parts()
解决方法
该循环显式地将所有具有偶数的节点添加到单个列表 (sublist_list) 中。语句 sublist_list = list() 只执行一次，因此您不可能希望获得多个这样的列表。
其次，即使您设法创建了数量可变的列表，您仍然需要有逻辑来反转这些新列表（微不足道），并替换内部的原始子列表带有反向列表的原始列表（不太重要）。
归根结底，这并没有让事情变得更容易。
我建议首先让您的 reverse_list_recursive 函数更加通用，这样它也可以通过让它接受另外两个参数来完成列表的子部分的工作：节点在该部分之前，节点在它之后。默认情况下，两者都是 None，这意味着整个列表应该颠倒。
我还建议不要使用递归解决方案，因为这将使用与列表中的节点数成线性关系的堆栈空间，因此如果列表有数千个节点，您将遇到堆栈大小限制。
所以这是一个迭代反向函数，它接受这些额外的可选参数：
def reverse(self,before_first=None,after_last=None):
prev = after_last
current = before_first.next if before_first else self.head
while current and current != after_last:
prev,current.next,current = current,prev,current.next
if before_first:
before_first.next = prev
else:
self.head = prev
现在最难的部分已经完成了，因为您现在只需要识别绑定偶数节点序列的节点：
def reverse_sub_parts(self):
prev = None
current = self.head
while current:
if current.data % 2 == 0:
if not prev or prev.data % 2 == 1:
before_start = prev
elif prev and prev.data % 2 == 0:
self.reverse(before_start,current)
prev = current
current = current.next
if prev and prev.data % 2 == 0:
self.reverse(before_start)