目录
本文使用的链表函数方法用到了LinkedList（即第一点实现链表类）
1.实现链表类
题目：
实现链表的插入，增加，查找，删除，查看长度和打印的方法。链表的介绍如下：
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
链表中每一个元素称为结点，链表由一系列结点组成，结点可以在运行时动态生成。
链表的每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
要求：
Node 类是定义的结点类。
Node 中的 __init__ 方法用于初始化结点，结点包含数据元素 data 和指向下一个结点地址的指针 next_node。
Node 中的 __str__ 方法用于返回当使用 print 输出对象时打印的信息，它需要返回结点的数据元素。
LinkedList 类是定义的链表类。
LinkedList 中的 __init__ 方法用于初始化链表，参数 head 为链表头的指针。
LinkedList 中的 __len__ 方法用于返回链表的结点个数，它需要返回一个数字。
LinkedList 中的 insert_to_front 方法用于在链表前面插入结点，参数 data 用于指定结点的数据元素，它需要返回插入的结点。如果 data 为 None 则返回 None。
LinkedList 中的 append 方法用于在链表后面增加结点，参数 data 用于指定结点的数据元素，它需要返回增加的结点。如果 data 为 None 则返回 None。
LinkedList 中的 find 方法用于查找链表中包含指定数据元素的结点，参数 data 用于指定结点的数据元素，它需要返回找到的结点。如果无法找到数据，则返回 None。
LinkedList 中的 delete 方法用于删除链表中包含指定数据元素的结点，参数 data 用于指定结点的数据元素，它不需要返回任何值。如果链表没有结点，或者指定元素不在链表中，则不进行删除操作。
LinkedList 中的 print_list 方法用于打印链表所有结点的数据元素。它需要使用 print 函数从链表头至链表尾依次打印出结点的数据元素
LinkedList 中的 get_all_data 方法用于将链表转化为数组，数组的元素为链表结点的数据元素，它需要返回一个数组。
class Node(object):
def __init__(self, data, next_node=None):
self.data=data
self.next=next_node
def __str__(self):
return str(self.data)
class LinkedList(object):
def __init__(self, head=None):
self.head=head
def __len__(self):
ans=0
current=self.head
while current!=None:
current=current.next
ans+=1
return ans
def insert_to_front(self, data):
if data==None:
return None
x=Node(data)
x.next=self.head
self.head=x
return x
def append(self, data):
if data is None:
return None
x=Node(data)
if self.head==None:
self.head=x
return x
current=self.head
while current.next!=None:
current=current.next
current.next=x
return x
def find(self, data):
if data==None:
return None
current=self.head
while current!=None:
if current.data==data:
return current
current=current.next
return None
def delete(self, data):
if data == None or self.head == None:
return None
current = self.head
if current.data == data:
self.head = current.next
return current
while current.next != None:
if current.next.data == data:
temp = current.next
current.next = temp.next
return temp
current = current.next
return None
def print_list(self):
current = self.head
while current != None:
print(current)
current = current.next
def get_all_data(self):
current = self.head
x = []
while current != None:
x.append(current.data)
current = current.next
return x2.删除链表的重复项
题目：
实现一个算法来删除链表中数据元素重复的结点。要求如下：
对于链表中有相同数据元素的结点，删除后面的重复结点
要求：
- MyLinkedList 类继承“实现链表类”挑战中的 LinkedList 类。
- MyLinkedList 类的 remove_dupes 方法用于删除链表的重复项，它没有输入，也没有返回值。
如果链表没有结点，则不进行操作
def remove_dupes(self):
cd=[]
node=self.head
while node:
if node.data in cd:
pre.next=node.next
else:
cd.append(node.data)
pre=node
node=node.next3.寻找链表倒数第 k+1 个结点
题目：
实现一个算法来寻找离链表最后一个结点 k 个距离的结点，即链表倒数第 k+1 个结点，并得到此结点的数据元素
要求：
MyLinkedList 类继承“实现链表类”挑战中的 LinkedList 类。
MyLinkedList 类的 kth_to_last_elem 方法用于寻找离链表最后一个结点 k 个距离的结点，参数 k 用于指定距离，它需要返回结点的数据元素。
如果链表没有结点，则返回 None；如果 k 大于或等于链表的长度，也返回 None
def kth_to_last_elem(self, k):
len=self.__len__()
if len==0 or len<k:
return None
index=len-k-1
node=self.head
while True:
if index==0:
return node.data
else:
node=node.next
index-=14.删除链表的结点
题目：
实现一个算法来删除链表的结点
要求：
MyLinkedList 类继承“实现链表类”挑战中的 LinkedList 类。
MyLinkedList 类的 delete_node 方法用于删除链表的结点，参数 node 用于指定需要删除的结点，它没有返回值。
如果要删除的结点位于链表末尾，则将链表最后一个结点的数据元素替换为 None。
如果链表没有结点，或者要删除的结点为 None，则不进行删除操作
def delete_node(self, node):
if self.__len__()==0 or node==None:
return
if node.next==None:
node.data=None
else:
node.data=node.next.data
node.next=node.next.next5.对链表值进行分区
题目：
实现一个算法来对链表中结点的元素值进行分区，使所有小于 x 的节点排在所有大于或等于 x 的节点之前。要求如下：
对于给定值 x，将链表的结点的顺序排为：值小于 x 的结点，值等于 x 的结点，值大于 x 的结点。
对于分区的每部分，即值小于 x 的部分和值大于 x 的部分，不需要按值的大小再进行排序，而是按照原本链表的顺序进行链接。例如值为 [4, 8, 5, 2, 5] 的链表按 5 进行分区的结果为 [4, 2, 5, 5, 8]
要求：
MyLinkedList 类的 partition 方法用于对链表中结点的元素值进行分区，参数 data 用于指定分区的临界值，它需要返回分区后的链表。
如果链表没有结点，则不进行分区操作
def partition(self, data):
if self.head is None:
pass
cur=self.head
node1=[]
node2=[]
while cur:
if cur.data>data:
node1.append(cur.data)
next=cur.next
self.delete(cur.data)
elif cur.data==data:
node2.append(cur.data)
next=cur.next
self.delete(cur.data)
else:
next=cur.next
cur=next
for i in node2:
self.append(i)
for i in node1:
self.append(i)
return self6.对链表值进行求和
题目：
实现一个算法来对链表中结点的元素值进行求和。要求如下：
数字以相反的顺序存储在链表中，如数字 37 在链表中存储的方式是，第 1 个结点为数字 7 ，第 2 个结点为数字 3 。
求和是把两个链表的数字求和后，以相反的顺序存储在链表中。例如第一个链表的数字是 37，即输入为 7 -> 3，第二个链表输入为 2 -> 8，则输出链表为 9 -> 1 -> 1
要求：
MyLinkedList 类的 add_reverse 方法用于对链表数字进行求和，参数 first_list 用于指定传入的第一个链表，参数 second_list 用于指定传入的第二个链表，它返回一个链表。
如果传入链表中有 None，则返回 None
def add_reverse(self, first_list, second_list):
def add(list):
return int(''.join(map(str, list.get_all_data()))[::~0] or 0)
if first_list and second_list:
for i in str(add(first_list) + add(second_list)):
self.insert_to_front(int(i))
return self7.寻找链表循环的起点
题目：
对于有循环的链表，实现一个算法来寻找链表循环的起点。要求如下：
例如链表以第 2，3，4 个结点为循环，即结点链接顺序为 head -> 1 -> 2 -> 3 -> 4 -> 2 -> 3 -> 4 -> ··· ，需要返回第 2 个结点
要求：
MyLinkedList 类的 find_loop_start 方法用于寻找链表循环的起点，它没有输入值，需要返回一个结点。
如果链表没有结点，则返回 None；如果链表中没有循环，也返回 None
def find_loop_start(self):
se=set()
node=self.head
while node:
if node in se:
return node
se.add(node)
node=node.next8.确定链表值是否为回文结构
题目：
实现一个算法来检测链表结点的数据元素是否为回文结构。回文的解释如下：
回文是从头读到尾与从尾读到头一模一样的结构，例如 abcba，1221
要求：
MyLinkedList 类的 is_palindrome 方法用于检测链表结点的数据元素是否为回文结构，它没有输入值，需要返回一个布尔值，即 True 或 False。
如果链表没有结点，则返回 False；如果链表只有一个结点，也返回 False
from linked_list import LinkedList
class MyLinkedList(LinkedList):
def is_palindrome(self):
return bool(self.head) and self.__len__() > 1 and self.get_all_data() == self.get_all_data()[::-1]
扫一扫
911
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
