python 链表和列表,Python实现列表和链表

Python实现列表和链表

list[index] O(1)

list.append O(1)

list.insert O(n)

list.pop(index) 默认删last O(1)

list.remove(element) O(n)

class Array(object):

def __init__(self, size=32):

self._size = size

self._items = [None] * self._size

def __getitem__(self, index):

return self._items[index]

def __setitem__(self, index, value):

self._items[index] = value

def __len__(self):

return self._size

def clear(self, value=None):

for i in range(len(self._items)):

self._items[i] = value

def __iter__(self):

for item in self._items:

yield item

单链表

缺点:1. remove时是O(n) 2.只能单向遍历

linked_list.append(value) O(1)

linked_list.appendleft(value) O(1)

linked_list.find(value) O(n)

linked_list.remove(value) O(n)

class Node(object):

def __init__(self, value=None, next=None):

self.value, self.next = value, next

class LinkedList(object):

def __init__(self, msxsize=None):

# msxsize=None代表无限大

self.maxsize = msxsize

# self.root 是根节点,根节点的next一般指向头节点head节点

self.root = Node()

self.length = 0

# self.tailnode表示最后一个节点

self.tailnode = None

def __len__(self):

return self.length

def append(self, value):

# 判断当前最大值是否超过了允许的最大值

if self.maxsize is not None and len(self) > self.maxsize:

raise Exception("Full")

node = Node(value)

tailnode = self.tailnode

if tailnode is None:

# 表明现在只有一个root节点, 然后指向当前的node节点即可

self.root.next = node

else:

# 否则把最后一个节点的next指向当前的node节点

self.tailnode.next = node

# 更新最后一个节点为node,因为我们把node放到了最后,而self.tailnode代表最后一个节点,所以要更新

self.tailnode = node

# 链表长度加一

self.length += 1

def appendleft(self, value):

# 定义头节点

headnode = self.root.next

node = Node(value)

# 根节点指向新的head节点: node节点

self.root.next = node

# node节点指向之前的head节点

node.next = headnode

self.length += 1

def iter_node(self):

# 第一个节点

curnode = self.root.next

# 当前节点不是最后一个节点时

while curnode is not self.tailnode:

yield curnode

# 当前节点更新为下一个节点

curnode = curnode.next

# 寻找到最后节点时,也需要把最后一个节点yield出来

yield curnode

def __iter__(self):

for node in self.iter_node():

yield node.value

def remove(self, value):

"""

删除包含值的一个节点,将其前一个节点的next指向下一个节点即可 O(n)

:param value:

:return:

"""

# 根节点

prevnode = self.root

for curnode in self.iter_node():

if curnode.value == value:

prevnode.next = curnode.next

if curnode is self.tailnode:

# 注意更新 tailnode

self.tailnode = prevnode

del curnode

self.length -= 1

# 返回1代表成功

return 1

else:

# 更新 prevnode

prevnode = curnode

# 返回-1表示删除失败

return -1

def find(self, value):

# O(n)

index = 0

for node in self.iter_node():

if node.value == value:

return index

index += 1

# 返回-1表示没找到

return -1

def popleft(self):

# O(1)

if self.root.next is None:

raise Exception("pop from empty LinkedList")

headnode = self.root.next

# 根节点指向头节点的下一个节点

self.root.next = headnode.next

value = headnode.value

self.length -= 1

del headnode

return value

def clear(self):

for node in self.iter_node():

del node

self.root.next = None

self.length = 0

双端链表

class Node(object):

def __init__(self, value=None, prev=None, next=None):

self.value, self.prev, self.next = value, prev, next

class CirculaDoubleLinkedList(object):

def __init__(self, msxsize=None):

# msxsize=None代表无限大

self.maxsize = msxsize

node = Node()

node.next, node.prev = node, node

self.root = node

self.length = 0

def __len__(self):

return self.length

def headnode(self):

return self.root.next

def tailnode(self):

# 根节点的prev指向尾节点

return self.root.prev

def append(self, value):

# 判断当前最大值是否超过了允许的最大值

if self.maxsize is not None and len(self) > self.maxsize:

raise Exception("Full")

node = Node(value=value)

tailnode = self.tailnode()

# 最后一个节点指向新的最后节点

tailnode.next = node

# 新的最后节点指向前节点

node.prev = tailnode

# node的下一个节点指向root

node.next = self.root

# 根节点的上一个节点指向新的最后节点,形成闭环

self.root.prev = node

self.length += 1

def appendleft(self, value):

# 判断当前最大值是否超过了允许的最大值

if self.maxsize is not None and len(self) > self.maxsize:

raise Exception("Full")

node = Node(value=value)

# 如果根节点的下一个节点是自己,则证明是空的

if self.root.next is self.root:

# 新节点的下一个指向根节点

node.next = self.root

# 新节点的上一个指向根节点

node.prev = self.root

# 根节点的下一个指向新节点

self.root.next = node

# 根节点的上一个指向新节点

self.root.prev = node

else:

# 新节点的上一个节点指向根节点

node.prev = self.root

# 获取头节点

headnode = self.headnode()

# 新节点的下一个指向头节点

node.next = headnode

# 头节点的上一个指向新节点

headnode.prev = node

# 根节点的下一个指向新节点

self.root.next = node

self.length+=1

def remove(self, node):

# O(1) node is not value

if node is self.root:

return

else:

# 被删除节点的上一个节点的next指向被删除节点的下一个节点

node.prev.next = node.next

# 被删除节点的下一个节点的prev指向被删除节点的上一个节点

node.next.prev = node.prev

self.length -= 1

return node

def iter_node(self):

if self.root.next is self.root:

return

curnode = self.root.next

while curnode is not self.root:

yield curnode

curnode = curnode.next

yield curnode

def __iter__(self):

for node in self.iter_node():

yield node.value

def iter_node_reverse(self):

if self.root.next is self.root:

return

curnode = self.root.prev

while curnode is not self.root:

yield curnode

curnode = curnode.prev

yield curnode

原文:https://www.cnblogs.com/guotianbao/p/12728883.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python链表列表是两种不同的数据结构。 列表(List)是Python中最用的数据类型之一。它是一种有序、可变的集合,可以包含任意类型的元素。列表使用方括号 [] 来表示,元素之间使用逗号分隔。列表支持索引和切片操作,可以进行增删改查等操作。 链表(Linked List)是一种数据结构,由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。不同于列表链表的内存分配不是连续的,而是通过指针将节点连接起来。链表的优点是插入和删除操作比较高效,但是访问某个特定位置的元素需要遍历整个链表,效率较低。 在Python中,没有内置的链表类型。但可以通过类和对象的方式来实现链表。例如,可以定义一个Node类表示链表的节点,然后使用这个类创建节点对象并通过指针连接它们。 以下是一个简单的链表示例: ```python class Node: def __init__(self, data): self.data = data self.next = None # 创建链表 node1 = Node(1) node2 = Node(2) node3 = Node(3) node1.next = node2 node2.next = node3 # 遍历链表 current = node1 while current: print(current.data) current = current.next ``` 这是一个包含3个节点的链表,节点的数据分别为1、2和3。通过 `next` 指针将它们连接起来,并使用循环遍历链表并输出节点的数据。 需要注意的是,Python列表操作更加灵活和方便,而链表则适合于频繁进行插入和删除操作的场景。根据实际需求选择合适的数据结构。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值