一．什么是链表
链表是由一系列节点构成，每个节点由一个值域和指针域构成，值域中存储着用户数据,指针域中存储这指向下一个节点的指针．根据结构的不同，链表可以分为单向链表、单向循环链表、双向链表、双向循环链表等。单向链表的结构如下图所示：
head 节点永远指向第一个节点， tail节点永远指向最后一个节点，节点中最后一个指针指向的是None 值，链表本质上就是由指针链接起来的一系列值．
二．为什么使用链表
我们经常拿链表和数组作比较，实际上数组是一组固定长度的序列，链表可以动态地分配元素，下面我们了解一下使用链表的优缺点
优点：
链表节省内存．它只针对待存储数据分配所需内存，在创建数组时，必须预先设置数组的大小，然后再添加数据，这可能会浪费内存。
缺点
查找或访问特定节点的时间是O(n). 在链接列表中查找值时，必须从头开始，并一次检查一每个元素以找到要查找的值。 如果链接列表的长度为n，则最多花费Ｏ(n)。
而很多语言中在数组中查找特定的元素则需花费O(1)时间
三．python 实现链表
1)节点
python 用类来实现链表的数据结构，节点（Node）是链表中存储数据的地方，除了数据之外节点中还有指向下一个节点的指针。节点是实现链表的基本模块，下边用python代码来实现一个节点类
class Node:
def _init_(self,val):
self.val=val
self.next_node = None #the pointer initially points to pointer
def get_val(self):
return self.val #returns the stored data
def get_next(self):
return self.next_node #returns the next node (the node to which the object node points)
def set_val(self, new_val):
self.val = new_val # reset the vaue to a new value
def set_next(self, new_next):
self.next_node = new_next # reset the pointer to a new node
此节点类只有一个构建函数，接收一个数据参数，其中next表示指针域的指针，接下来我们用如下方式去初始化一个链表：
node1 = Node(4)
node2 = Node(21)
node3 = Node(90)
node1.next = node2 #4->21
node2.next = node3 #21->90
# the entire linked list now looks like: ４->21->90
借助上边的节点类我们可以很方便的构造出链表
２）链表
单向链表的实现包含了如下几个方法：
append(): 向链表中增加一个元素
insert(): 向链表中插入一个新节点
size(): 返回链表的长度
search(): 在链表中查找数据项是否存在
delete(): 删除链表中的数据项
empty(): 判断链表是否为空
iterate(): 遍历链表
链表的头结点：
首先构建链表的头结点也就是链表中的第一个节点，当链表在初始化时不包含任何节点，所以它的头节点设置为空
class LinkedList:
def _init_(self):
self.head = None
self.tail = None
实例化代码如下
linklist = LinkedList()
append()
append方法表示增加元素到链表，这和insert方法不同，前者使新增加的元素成为链表中第一个节点，而后者是根据索引值来判断插入到链表的哪个位置。代码如下:
def append(self, val):
new_node = Node(val)
if self.head is None:
self.head = new_node
self.tail = new_node
else:
self.tail.set_next(new_node)
self.tail = new_node
insert()
该方法获得一个数据，对于给定数据初始化一个节点，并将该节点添加到链表中去。最简单的实现方法是把它插入到链表头处，并让新节点指向原来的头结点，该方法二时间复杂度为O(1)：
def insert(self, val):
new_node = Node(val)
new_node.set_next(self.head)
self.head = new_node
如果要在特定位置插入节点要提前找到这个位置，在链表中只能采用遍历的方法，时间复杂度为O(n). 同时我们还要考虑额外的三种情况：
１）空链表时
２）插入位置超出链表节点的长度时
３）插入位置是链表的最后一个节点时，需要移动tail
def insert(self, index, val):
current_node = self.head
current_node_index = 9
if current_node is None:
raise Exception('This is an empty linked list')
while current_node_index < index-1:
current_node = current_node.next
if current_node is None:
raise Exception('exceed the length of the list')
current_node_index += 1
node = Node(val)
node.next = current_node.next
current_node.next = node
if node.next is None:
self.tail = node
size()
返回链表长度的方法非常简单，统计链表中的节点数目直到找不到更多的节点为止返回遍历的节点的数目。该方法从表头开始，直到最后一个节点的next指针指向None时链表遍历完成。同时用计数器记录下已经遍历的节点的数目
def size(self):
current_node = self.head
count = 0
if current_node is None:
return 'This is an empty linked list'
while current_node:
count += 1
current_node = current_node.get_next()
return count
search()
search()与size() 方法很相似，但是除了要遍历整个链表，search()还要检查他遍历的每一个节点是否包含要查找的数据，并返回含有该数据的节点。如果该方法遍历整个链表没有找到包含该数据的节点，它将会抛出一个异常并通知用户该数据不在链表中
def search(self, val):
current_node = self.head
found = false
while current_node and found is false:
if current_node.get_val == val:
found = True
else:
current_node = current_node.get_next()
if current_node is None:
raise ValueError('Data not in list')
delete()
delete()与search()方法非常相似，它采用与serch()相同的方法遍历整个链表，但除了要记录下当前节点之外, delete()还要记住当前节点的上一个节点，当deleta()方法遍历到要删除的节点时，它会将待删除节点的上一个节点的指针指向待删除节点的下一个节点，此时链表中将没有节点指向待删除节点。该方法的时间复杂度为O(n),因为在最坏情况下该方法要访问链表中的所有节点。同时我们还需要考虑如下几种情况：
1) 空链表，直接抛出异常
2) 删除第一个节点时，移动head到删除节点的next指针指向的对象
3) 链表只有一个节点时，把head与tail都指向None即可
4) 删除最后一个节点时，需要移动tail到上一个节点
5) 遍历链表时要判断给定的索引是否大于链表的长度，如果大于则抛出异常信息
def delete(self, val):
curent_node = self.head
previous = None
found = False
while current_node and found is False:
if current_node.get_val() == val:
found = True
else:
previous = current_node
current_node = current_node.get_next()
if current_node is None:
raise ValueError('Data not in list')
if self.head is self.tail: # when there is only one node in the list
self.head = None
self.tail = None
if current_node is None: #when delete the tail node
self.tail = current_node
if previous is None: #when delete the first node
self.head = current_node.get_next()
else :
previous.set_next(current.get_next())
empty()
判断链表是否为空就看他的头指针是否为空
def empty(self):
return return self.head is None
iterate()
遍历链表从头结点开始，直到节点的指针指向Ｎｏｎｅ为止
def iterate(self):
if not self.head: # if the linked list is empty
return
current_node = self.head
yield current_node.val
while current_node.next
current_node = current_node.next
yield current_node.val
完整代码如下
1 class Node:
2 def __init__(self,val):
3 self.val=val
4 self.next = None #the pointer initially points to pointer
5 def get_val(self):
6 return self.val
7 def get_next(self):
8 return self.next
9 def set_val(self, new_val):
10 self.val = new_val
11 def set_next(self, new_next):
12 self.next = new_next
13
14 class LinkedList:
15 def __init__(self):
16 self.head = None
17 self.tail = None
18
19 def insert(self, index, val):
20 current_node = self.head
21 current_node_index = 0
22 if current_node is None:
23 raise Exception('This is an empty linked list')
24 while current_node_index < index-1:
25 current_node = current_node.next
26 if current_node is None:
27 raise Exception('exceed the length of the list')
28 current_node_index += 1
29 node = Node(val)
30 node.next = current_node.next
31 current_node.next = node
32 if node.next is None:
33 self.tail = node
34 def size(self):
35 current_node = self.head
36 count = 0
37 if current_node is None:
38 return 'This is an empty linked list'
39 while current_node:
40 count += 1
41 current_node = current_node.get_next()
42 return count
43
44 def search(self, val):
45 current_node = self.head
46 found = False
47 while current_node and found is False:
48 if current_node.get_val() == val:
49 found = True
50 else:
51 current_node = current_node.get_next()
52 if current_node is None:
53 raise ValueError('Data not in list')
54 return found
55
56 def delete(self, val):
57 current_node = self.head
58 previous = None
59 found = False
60 while current_node and found is False:
61 if current_node.get_val() == val:
62 found = True
63 else:
64 previous = current_node
65 current_node = current_node.get_next()
66
67 if current_node is None:
68 raise ValueError('Data not in list')
69
70 if self.head is self.tail:
71 self.head = None
72 self.tail = None
73
74 if current_node is None:
75 self.tail = current_node
76
77 if previous is None:
78 self.head = current_node.get_next()
79 else :
80 previous.set_next(current.get_next())
81
82 def iterate(self):
83 if not self.head:
84 return
85 current_node = self.head
86 yield current_node.val
87 while current_node.next:
88 current_node = current_node.next
89 yield current_node.val
90
91 def append(self, val):
92 new_node = Node(val)
93 if self.head is None:
94 self.head = new_node
95 self.tail = new_node
96 else:
97 self.tail.set_next(new_node)
98 self.tail = new_node
99 def empty(self):
100 return self.head is None
101
102 if __name__ == '__main__':
103 linklist = LinkedList()
104 for i in range(50):
105 linklist.append(i)
106 print(linklist.empty())
107 linklist.insert(20,20)
108 linklist.delete(0)
109 for node in linklist.iterate():
110 print('node is {0}'.format(node))
111 print(linklist.size())
112 print(linklist.search(13))
参考链接：
https://www.codefellows.org/blog/implementing-a-singly-linked-list-in-python/
