python实现链表

链表

链表似乎完全可以用deque双向列表替代。
在python中，还有必要自己再造轮子吗？

'''
	链表: 在python中，我实在不知道链表有什么用处！
'''
from timeit import Timer
from collections import deque
class ListNode:
	'''
	# 这是一个节点类
	>>> temp = ListNode(93)
	'''
	def __init__(self, init_data=0):
		self.data = init_data
		self.next, self.prev = None, None

	def __str__(self):
		return str(self.data)


class DobleLink:
	'''
	头部插入：insert(0, item)
	尾部插入：insert(-1, item) or append(item)
	头部取出：pop(0)
	尾部取出：pop()
	删除元素：pop(index)
	支持负数索引
	'''
	def __init__(self, item=0):
		self.head = ListNode(item)
		self.tail = ListNode(item)
		self.head.next, self.tail.prev = self.tail, self.head
		self.size = 0

	def __len__(self):
		return self.size

	def __re_index(self, index):
		'''
		该语句表示支持反向索引 例如长度为5： 5 - 4 = 1 
		index = index if index >= 0 else self.size + index
		'''
		return index if index >= 0 else self.size + index

	def is_empyt(self):
		return self.head.data == None

	def __set(self, index, item):
		node = ListNode(item)
		# temp为index为插入位置的节点
		temp = self.index(index)
		
		temp.prev.next = node
		node.prev = temp.prev
		node.next = temp
		temp.prev = node

		self.size += 1

		
	def search(self, item):
		pass

	def __remove(self, temp, item=None):
		temp.prev.next = temp.next
		temp.next.prev = temp.prev
		return temp

	def append(self, item):
		return self.__set(self.size, item)

	def insert(self, index, item):
		if index < 0: 
			index = self.__re_index(index) + 1
		else: index = self.__re_index(index)
		return self.__set(index, item)

	def appendleft(self, item):
		'''等同于 insert(0, item)'''
		return self.insert(0, item)

	def index(self, index:int):
		'''
		分三种情况，查找索引指向的节点
		1. append 时： index == self.size
		2. 倒着找节点： index > self.size - index
		3. 顺着找节点： index < self.size - index
		'''
		if index < 0 or index > self.size:
			raise IndexError("索引异常")
		
		# 分三种情况，找到索引指向的节点
		if index == self.size:			# append()直接操作最后一个节点
			temp = self.tail

		elif index > self.size - index: # 倒着找，哪边近就从哪边开始找
			temp = self.tail
			for _ in range(self.size - index):
				temp = temp.prev
		else:							# 顺着找
			temp = self.head
			for _ in range(index + 1):
				temp = temp.next
		return temp


	def pop(self, index=-1):
		index = self.__re_index(index)
		temp = self.index(index)
		return self.__remove(temp)

	def __str__(self):
		temp = self.head.next
		t = []
		while temp:
			t.append(temp.data)
			temp = temp.next
		t.pop()
		return str(t)

'''
三次实验：
1. 从头部添加数据
	链表： 0.39ms
	list： 13ms
	deque：0.03ms
结论：deque < 链表 < list
2. 从尾部添加数据
	链表： 0.25ms
	list： 0.02ms
	deque：0.02ms
结论：deque = list < 链表
3. 从中间插入数据
	链表： 10ms
	list： 14ms
	deque：0.35ms
结论：deque < 链表 = list
4. 删除数据,尾部删除就不用试了,自己实现的链表肯定完败
从头部删除，共十万数据，删完为止
	链表： 0.1 ms
	list：1.5 ms
	deque：0.003ms
结论：deque < 链表 < list

结论：失了智才会用python写链表
'''
if __name__ == '__main__':
		
	t = DobleLink()
	d = []
	b = deque()
	for i in range(100000):
		t.append(1)
		d.append(1)
		b.append(1)


	def test1():
		try:
			for i in range(2000):
				# t.insert(0, 1)
				# t.append(1)
				# t.insert(1000, 1)
				t.pop(0)
		except:pass

	def test2():
		try:
			for i in range(2000):
				# d.insert(0, 1)
				# d.append(1)
				# d.insert(1000, 1)
				d.pop(0)
		except:pass


	def test3():
		try:
			# print(1)
			for i in range(2000):
				# b.insert(0, 1)
				# b.append(1)
				# b.insert(1000, 1)
				b.pop(0)
				# print()
		except: pass

	t1 = Timer("test1()", "from __main__ import test1")
	t2 = Timer("test2()", "from __main__ import test2")
	t3 = Timer("test3()", "from __main__ import test3")

	print("t1", t1.timeit(number=3000), "milliseconds")
	print("t2", t2.timeit(number=3000), "milliseconds")
	print("t3", t3.timeit(number=3000), "milliseconds")