python算法：LinkedList（双向线性链表）的实现

LinkedList是一个双向线性链表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。

首先，我们来实现一个Node，看代码：

class Node(object):
def __init__(self,value,prev_Node=None,next_Node=None):
self.value=value
self.prev_node=prev_Node
self.next_node=next_Node

def get_prev_node(self):
return self._prev_node

def set_prev_node(self,prev_Node):
self._prev_node=prev_Node

def del_prev_node(self):
del self._prev_node

prev_node=property(get_prev_node,set_prev_node,del_prev_node)

def get_next_node(self):
return self._next_node

def set_next_node(self,next_Node):
self._next_node=next_Node

def del_next_node(self):
del self._next_Node

next_Node=property(get_next_node,set_next_node,del_next_node)

def get_value(self):
return self._value

def set_value(self,value):
self._value=value

def del_value(self):
del self._value

value=property(get_value,set_value,del_value)

然后，生成LinkedList：

class LinkedList(object):
# comparator is a function used by LinkedList to compare nodes
# it's expected to take two parameters:
# it returns 0 if both parameters are equal, 1 if the left parameter is greater, and -1 if the lft parameter is lesser
def __init__(self, comparator):
self.head = None
self.comparator = comparator

# Adds a value to the LinkedList while maintaining a sorted state
def insert(self, value):
node = Node(value)

# If the linked list is empty, make this the head node
if self.head is None:
self.head = node
# Otherwise, insert the node into the sorted linked list
else:
curr_node = self.head
b_node_not_added = True
while b_node_not_added:
result = self.comparator(node.value, curr_node.value)

# Store the next and previous node for readability
prev = curr_node.prev_node
next = curr_node.next_node

# If the current node is greater, then insert this node into its spot
if result < 0:
# If the curr_node was the head, replace it with this node
if self.head == curr_node:
self.head = node
# Otherwise, it has a previous node so hook it up to this node
else:
node.prev_node = prev
prev.next_node = node

# Hook the current node up to this node
node.next_node = curr_node
curr_node.prev_node = node

b_node_not_added = False
# Otherwise, continue traversing
else:
# If we haven't reached the end of the list, keep traversing
if next is not None:
curr_node = next
# Otherwise, append this node
else:
curr_node.next_node = node
node.prev_node = curr_node

b_node_not_added = False

def remove(self, value):
curr_node = self.head

while curr_node is not None:
# Store the current node's neighbors for readability
prev = curr_node.prev_node
next = curr_node.next_node

# Check if this is the node we're looking for
result = self.comparator(value, curr_node.value)

# If it's equal, then remove the current node
b_node_is_equal = result == 0
if b_node_is_equal:
# If the removed node is the head node, re-assign the head node
if self.head == curr_node:
self.head = next
# Otherwise, remove the node normally
else:
if prev is not None:
prev.next_node = next
if next is not None:
next.prev_node = prev

curr_node = None
# Otherwise, continue traversing the list
else:
curr_node = next

# Print out the contents of the linked list
def print(self):
curr_node = self.head
while curr_node is not None:
print(curr_node.value)
curr_node = curr_node.next_node