链表

单链表

#先定义一个节点
class Node(object):
    def __init__(self, value, next=None):
    	self.value = value
    	self.next = next


#定义链表
class LinkedList(object):
    def __init__(self, maxsize):
    	self.maxsize = maxsize
    	self.root = Node()
    	self.tailnode = None
    	self.length = 0
    
    #添加节点，时间复杂度：O(1)
    def append(self, value):      
    	if self.maxsize is not None and len(self) >= self.maxsize:
    	    raise Exception('LikedList is Full')
    	node = Node(value)
    	tailnode = self.tailnode
    	if tailnode is None:
    	    self.root.next = node
    	else:
    	    tailnode.next = node
    	self.tailnode = node
    	self.length += 1

    #左侧添加节点，时间复杂度：O(1)
    def appendleft(self, value):
    	if self.maxsize is not None and len(self) >= self.maxsize:
    	    raise Exception('LinkedList is Full')
    	node = Node(value)
    	if self.tailnode is None:
    	    self.tailnode = node
    	headnode = self.root.next
    	self.root.next = node
    	node.next = headnode
    	self.length += 1

    def __iter__(self):
    	for node in self.iter_node():
    	    yield node.value
    
    #遍历从head节点到tail节点
    def iter_node(self):
        curnode = self.root.next
        while curnode is not self.tailnode: #从第一个节点开始遍历
            yield curnode
            curnode = curnode.next
        if curnode is not None:     #最后一个节点不能忘！！！
            yield curnode

    #删除包含某个值的节点，时间复杂度：O(n)
    def remove(self, value):
        prevnode = self.root.next
        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
            	return 1               #表明删除成功 
            prevnode = curnode
        return -1                      #表明删除失败

    #查找一个节点并返回索引，时间复杂度：O(n)
    def find(self, value):
    	index = 0
    	for node in self.iter_node():
    	    if node.value == value:
    	    	return index
    	    index += 1
    	return -1                       #查找失败

    #删除第一个链表节点，时间复杂度：O(1)
    def popleft(self):
    	if self.root.next is None:
    	    raise Exception('Pop from Empty')
    	headnode = self.root.next
    	self.root.next = headnode.next
    	self.length -= 1
    	value = headnode.value
    	#如果删除的第一个节点刚好是尾节点
    	if self.tailnode is headnode:
    	    self.tailnode = None
    	del headnode
    	return value

    #清空链表，时间复杂度：O(n)
    def clear(self):
        for node in self.iter_node():
            del node
        self.root.next = None
        self.length = 0
        self.tailnode = None

双链表

class Node(object):
	def __init__(self, value=None, prev=None, next=None):
		self.value, self.prev, self.next = value, prev, next


class CircularDoubleLinkedList(object):
	def __init__(self, maxsize=None):
		self.maxsize = maxsize
		node = Node()
		self.prev, self.next = node, node
		self.root = node
		self.length = 0

	def __len__(self):
		return self.length

	def headnode(self):
		return self.root.next

	def tailnode(self):
		return self.root.prev

	#添加一个节点，时间复杂度：O(1)
	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() or self.root
		tailnode.next = node
		node.next = self.root
		node.prev = tailnode
		self.root.prev = node
		self.length += 1

	#在左侧添加一个节点，时间复杂度：O(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:
			self.root.next = node
			node.next = self.root
			node.prev = self.root
			self.root.prev = node
		else:
			node.prev = self.root
			headnode = self.root.next
			node.next = headnode
			headnode.prev = node
			self.root.next = node
		self.length += 1

	#删除节点，时间复杂度：O(1)
	def remove(self, value):
		if node is self.root:
			return
		else:
			node.prev.next = node.next
			node.next.prev = node.prev
		self.length -= 1
		return node

	def __iter__(self):
		for node in self.iter_node():
			yielf node.value

	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_node_reverse(self):
		if self.root.prev is self.root:
			return
		curnode = self.root.prev
		while curnode is not self.root:
			yield curnode
			curnode = curnode.prev
		yield curnode