细细琢磨了一下以前的这篇文章，感觉这样不太能体现链表的精髓，要想真的想深入研究链表这种数据结构，在没有指针的语言中，还是应该用静态链表来模拟真正链表比较好。
对于静态链表，个人认为要先想想下面几点：
-
静态链表的存储结构是什么？
-
没有指针，怎么来模拟指针？怎么模拟C语言中地址的概念
-
怎么去模拟内存管理？
OK， 先来聊聊第1、2点，静态链表在没有指针的语言中用数组来实现，用一组地址连续的存储单元来存放数据（第一次了解到这里，我也是懵圈的，数组？？？这不就是顺序表吗，怎么和链表扯上关系？），有意思的就来了，我们就用数组的下标来代替地址吧！！！对，要学会静态链表，你就先要把数组看做一个内存空间，数组下标就是这个空间的地址。C有指针就相当于可以在整个内存空间的海洋里遨游，而静态链表就是只能在自己搭建的舞台上起舞。
当你认识到数组来模拟一片内存空间，下标就是地址的时候，我们就要来解决实际问题了，也就是怎么模拟内存的管理？
一、肯定是定义节点item类，其中data保存数据，next保存下一个节点的下标（也可以理解为下一个的位置或者地址），静态链表类SLinkList，在初始化函数__init__里创建一个size+1大小的列表link（因为我的设计是将0节点设为头结点，不保存数据，用来记录链表长度length，链表尾部rear等信息）。
现在内存空间创建好了，那么问题又来了，我们怎么知道哪些节点是链表里面的，哪些节点是空闲的？在这里我想到了一个比较巧妙的方法，不用另外创建一个数组去存储空闲空间信息。因为初始化的时候所有的空间都是空闲的，我们可以先将所有的空闲节点连起来（也就是第i个节点保存第i+1个节点的位置），然后头结点用一个变量space指向第一个空闲空间的位置，这样我们就保持space永远指向一个空闲节点的位置，即可随时知道那个位置是空闲的了。代码如下，通过代码可以比较直观的理解我的意思。
1 class item (object): 2 def \_\_init\_\_(self, data):
3 self.data = data 4 self.next = None 5
6 class SLinkList(object): 7 '''
8 静态链表，就是用数组来模拟链表，那么数组的下标就当做是节点的地址，
9 这个概念是静态链表的核心
10 '''
11 def \_\_init\_\_(self, size = 100):
12 '''
13 初始化主要是用于初始化链表的大小，而非创建链表
14 '''
15 self.link = \[item(None) for i in range(size + 1)\] # 申请size大小的节点空间\[0,1,2,...,size\]，其中下标0的节点作为头结点
16 self.link\[0\].next = None # 表示空表
17 self.link\[0\].space = 1 # 指向第一个节点，因为初始化时第一个节点为空闲节点
18
19 i = 1
20 while i < size:
21 self.link\[i\].next = i+1 # 利用空闲节点连成一个新的表，并且头结点的space始终指向下一个空闲的节点
22 i += 1
23
24 self.link\[i\].next = None # 空闲表尾指向None
25
26 self.length = 0 # 链表长度
27 self.rear = 0 # 表尾指针
二、空闲空间已经有了，那么要怎么管理这片空间呢？C语言中新建一个节点会先用malloc函数申请一个内存空间，删除一个节点我们会用free函数来释放内存，在静态链表中我们需要自己实现，因为之前头结点space永远都会指向一个空闲节点的位置，所有我设计的malloc\_SL函数，直接从space获取一个空闲节点的位置，然后space再指向下一个空闲节点位置即可，而释放空间函数free\_SL同理，先将待释放的点保存space指向的空闲位置，再将space指向该点即可模拟内存回收的过程。代码如下：
1 def Malloc\_SL(self): 2 '''
3 类似于C中malloc函数申请空间，返回空闲节点的下标
4 '''
5 i = self.link\[0\].space 6 if self.link\[0\].space: 7 self.link\[0\].space = self.link\[i\].next 8
9 return i
10
11 def Free\_SL(self, k):
12 '''
13 释放空间，并返回下标k节点的值
14 '''
15 self.link\[k\].data = None
16 self.link\[k\].next = self.link\[0\].space
17 self.link\[0\].space = k
三、完成上面两点，静态链表的核心基本就说完了，其他的增删改查操作和c中的链表就差不多了，再提一次就是，静态链表的数组下标就相当于位置，地址！这里我再介绍一下的往链表末尾添加节点的操作函数Append（），流程就是先用Malloc\_SL函数申请一个空间节点的位置，然后在该位置添加数据，next指向None，成为新的表尾，再将表尾指针指向该新加入的节点，表长length + 1，代码如下：
1 def Append(self, data): 2 '''往链表表尾添加元素, 并返回新添加元素的下标'''
3 node\_index = self.Malloc\_SL() 4
5 if not node\_index: 6 print("Append: NO SPACE!")
7 return False 8
9 self.link\[node\_index\].data = data
10 self.link\[node\_index\].next = None
11 self.link\[self.rear\].next = node\_index
12 self.rear = node\_index
13 self.length += 1
14 return node\_index
四、最后我实现了几个链表的操作，其他操作有读者自己去琢磨：
- CreateSLinkList_R---->用尾插法插入元素，创建一个链表
- CreateSLinkList_F---->用头插法插入元素，创建一个链表
- DeleteElement--------->根据数据删除第一个匹配到的节点
- InsertBefore------------>在第k个节点前插入新节点
- Walk--------------------->遍历整个链表，并输出数据
- Detail-------------------->输出各节点的详细信息
全部代码如下：
1 class item (object): 2 def \_\_init\_\_(self, data):
3 self.data = data 4 self.next = None 5
6 class SLinkList(object): 7 '''
8 静态链表，就是用数组来模拟链表，那么数组的下标就当做是节点的地址，
9 这个概念是静态链表的核心
10 '''
11 def \_\_init\_\_(self, size = 100):
12 '''
13 初始化主要是用于初始化链表的大小，而非创建链表
14 '''
15 self.link = \[item(None) for i in range(size + 1)\] # 申请size大小的节点空间\[0,1,2,...,size\]，其中下标0的节点作为头结点
16 self.link\[0\].next = None # 表示空表
17 self.link\[0\].space = 1 # 指向第一个节点，因为初始化时第一个节点为空闲节点
18
19 i = 1
20 while i < size: 21 self.link\[i\].next = i+1 # 利用空闲节点连成一个新的表，并且头结点的space始终指向下一个空闲的节点
22 i += 1
23
24 self.link\[i\].next = None # 空闲表尾指向None
25
26 self.length = 0 # 链表长度
27 self.rear = 0 # 表尾指针
28
29 def CreateSLinkList\_R(self, data): 30 '''
31 用尾插法创建链表
32 '''
33 if self.length > 0: # 非空表无需创建
34 print("THIS SLINKLIST IS NOT NULL")
35 return
36
37 for each in data: 38 if not self.Append(each): 39 print("CreateR: NO SPACE!")
40 return
41
42
43 def CreateSLinkList\_F(self, data): 44 '''
45 用头插法创建链表
46 '''
47 if self.length > 0: # 非空表无需创建
48 print("THIS SLINKLIST IS NOT NULL")
49 return
50
51 self.Append(data\[0\]) # 先添加第一个节点
52 for each in data\[1:\]: # 在第一个位置前插入
53 if self.InsertBefore(each, 1) == 'NS':
54 print("CreateF: NO SPACE!")
55
56
57 def LocateElement(self, data): 58 '''
59 定位第一个与data值相同的节点，并返回该节点的下标
60 '''
61 i = self.link\[0\].next 62 while i and self.link\[i\] != data: 63 i = self.link\[i\].next 64 return i 65
66 def Malloc\_SL(self): 67 '''
68 类似于C中malloc函数申请空间，返回空闲节点的下标
69 '''
70 i = self.link\[0\].space 71 if self.link\[0\].space: 72 self.link\[0\].space = self.link\[i\].next 73
74 return i 75
76 def Free\_SL(self, k): 77 '''
78 释放空间，并返回下标k节点的值
79 '''
80 self.link\[k\].data = None 81 self.link\[k\].next = self.link\[0\].space 82 self.link\[0\].space = k 83
84 def DeleteElement(self, data): 85 '''
86 删除第一个匹配到的节点，并返回删除节点的下标
87 '''
88 prior = index = 0 89 while index != None and self.link\[index\].data != data: 90 prior = index 91 index = self.link\[index\].next 92
93 if not index: 94 print("DELETE:\\tNot Found!")
95 return False 96
97 if not self.link\[index\].next: # 判断是否是删除表尾元素，是则改变表尾指针
98 self.rear = prior 99
100 self.link\[prior\].next = self.link\[index\].next
101 self.length -= 1
102 self.Free\_SL(index)
103 return index
104
105 def InsertBefore(self, data, k):
106 '''
107 在第k个元素前插入元素, 并返回新节点下标
108 '''
109 if self.link\[0\].space == None: # 表满
110 print("no space!!!")
111 return "NS"
112
113 if k <= 0 or k > self.length: # 超出当前链表可插入范围
114 print("out of range!!!")
115 return "OFR"
116
117 count = 0
118 index = 0
119 while count < k - 1 : # 找到第k-1个节点，直接在改节点后插入新的元素
120 index = self.link\[index\].next
121 count += 1
122
123 node\_index = self.Malloc\_SL() # 申请一个新的节点
124 self.link\[node\_index\].data = data # 写入数据
125 self.link\[node\_index\].next = self.link\[index\].next # 将新节点的next指向第k个节点
126 self.link\[index\].next = node\_index # 将第k-1个节点的next指向新节点node\_index
127 self.length += 1
128 return node\_index
129
130 def Append(self, data):
131 '''往链表表尾添加元素, 并返回新添加元素的下标'''
132 node\_index = self.Malloc\_SL()
133
134 if not node\_index:
135 print("Append: NO SPACE!")
136 return False
137
138 self.link\[node\_index\].data = data
139 self.link\[node\_index\].next = None
140 self.link\[self.rear\].next = node\_index
141 self.rear = node\_index
142 self.length += 1
143 return node\_index
144
145 def Walk(self):
146 '''打印链表中所有元素'''
147 print("WALK:\\t", end = '')
148 index = self.link\[0\].next
149 while index:
150 print(self.link\[index\].data, end = '')
151 index = self.link\[index\].next
152 print("")
153
154 def Detail(self):
155 '''输出链表中各元素的详细信息'''
156 print("\\nDETAIL:")
157 index = self.link\[0\].next
158 count = 1
159 while index:
160 print("SN:\\t%d\\tDATA:\\t%s\\tADDR:\\t%d\\tNEXT:\\t%s" % \\
161 (count, self.link\[index\].data, index, str(self.link\[index\].next)))
162 index = self.link\[index\].next
163 count += 1
164
165 print("Length:\\t%d\\nRear:\\t%d\\n" % (self.length, self.rear))
166
167
168 if \_\_name\_\_ == '\_\_main\_\_':
169 SL = SLinkList()
170 while True:
171 print()
172 opt = input("请选择创建链表的方式： 1. 尾插法 2. 头插法\\nOPTION:\\t")
173 if opt == '1':
174 data\_str = input("INPUT DATA:\\t")
175 SL.CreateSLinkList\_R(data\_str)
176 break
177 elif opt == '2':
178 data\_str = input("INPUT DATA:\\t")
179 SL.CreateSLinkList\_F(data\_str)
180 break
181 else:
182 print("请做出正确选择！")
183 continue
184
185 while True:
186 opt = input("\\n请选择操作： 1. 插入数据 2. 删除数据 3. 遍历链表 4. 查看链表详细结构 5. 在链表末尾添加数据 6. 退出程序\\nOPTION:\\t")
187 if opt == '1':
188 data\_str = input("请输入插入数据：\\t")
189 pos = input("请输入插入位置：\\t")
190 node\_addr = SL.InsertBefore(data\_str\[0\], int(pos))
191 if node\_addr != 'NS' and node\_addr != 'OFR':
192 print("成功删除元素%s，元素地址为：%d" % (data\_str\[0\], node\_addr))
193 else:
194 print("INSERT ERROR!!!")
195
196 elif opt == '2':
197 data\_str = input("请输入删除数据：\\t")
198 data\_pos = SL.DeleteElement(data\_str\[0\])
199 if data\_pos:
200 print("成功删除元素%s，元素地址为：%d" % (data\_str\[0\],data\_pos))
201
202 elif opt == '3':
203 print('')
204 SL.Walk()
205 elif opt == '4':
206 SL.Detail()
207 elif opt == '5':
208 data\_str = input("请输入数据:\\t")
209 node\_addr = SL.Append(data\_str\[0\])
210 print("成功添加元素：\\t%s\\t元素地址为：\\t%d" % (data\_str\[0\], node\_addr))
211 elif opt == '6':
212 break
213 else:
214 print("请做出正确选择！")
View Code
下面是运行测试结果：
1. 尾插法保存 123456789（注意walk结果）
2. 头插法保存 123456789（注意walk结果）
- 经过一系列增删操作后的链表结构，可以看出静态链表较好的模拟了链表的动态分配内存的特点，不是按数组下标来顺序存储数据：
以上就是静态链表的基本内容，再留下一些问题让读者思考一下：
1. 用Python语言怎么修改可以让链表的空间动态增加？这样就成了动态链表了
2. Python用静态链表来实现链表结构和用多重对象的嵌套来实现链表结构哪种方法好点？为什么？（我也在琢磨这个事情）
这里以下是旧文章 ↓↓↓
数据结构是计算机科学必须掌握的一门学问，之前很多的教材都是用C语言实现链表，因为c有指针，可以很方便的控制内存，很方便就实现链表，其他的语言，则没那么方便，有很多都是用模拟链表，不过这次，我不是用模拟链表来实现，因为python是动态语言，可以直接把对象赋值给新的变量。
好了，在说我用python实现前，先简单说说链表吧。在我们存储一大波数据时，我们很多时候是使用数组，但是当我们执行插入操作的时候就是非常麻烦，看下面的例子，有一堆数据1,2,3,5,6,7我们要在3和5之间插入4,如果用数组，我们会怎么做？当然是将5之后的数据往后退一位，然后再插入4,这样非常麻烦，但是如果用链表，我就直接在3和5之间插入4就行，听着就很方便。
那么链表的结构是怎么样的呢？顾名思义，链表当然像锁链一样，由一节节节点连在一起，组成一条数据链。
链表的节点的结构如下：
| data | next |
data为自定义的数据，next为下一个节点的地址。
链表的结构为，head保存首位节点的地址：
接下来我们来用python实现链表
python实现链表
首先，定义节点类Node：
class Node:
'''
data: 节点保存的数据
\_next: 保存下一个节点对象
'''
def \_\_init\_\_(self, data, pnext=None):
self.data \= data
self.\_next \= pnext
def \_\_repr\_\_(self):
'''
用来定义Node的字符输出，
print为输出data '''
return str(self.data)
然后，定义链表类：
链表要包括：
属性：
链表头：head
链表长度：length
方法：
判断是否为空: isEmpty()
def isEmpty(self):
return (self.length == 0
增加一个节点(在链表尾添加): append()
def append(self, dataOrNode):
item \= None
if isinstance(dataOrNode, Node):
item \= dataOrNode
else:
item \= Node(dataOrNode)
if not self.head:
self.head \= item
self.length += 1
else:
node \= self.head
while node.\_next:
node \= node.\_next
node.\_next \= item
self.length += 1
删除一个节点: delete()
#删除一个节点之后记得要把链表长度减一
def delete(self, index):
if self.isEmpty():
print "this chain table is empty."
return
if index < 0 or index >= self.length:
print 'error: out of index'
return
#要注意删除第一个节点的情况
#如果有空的头节点就不用这样
#但是我不喜欢弄头节点
if index == 0:
self.head \= self.head.\_next
self.length \-= 1
return
#prev为保存前导节点
#node为保存当前节点
#当j与index相等时就
#相当于找到要删除的节点
j = 0
node \= self.head
prev \= self.head
while node.\_next and j < index:
prev \= node
node \= node.\_next
j += 1
if j == index:
prev.\_next \= node.\_next
self.length \-= 1
修改一个节点: update()
def update(self, index, data):
if self.isEmpty() or index < 0 or index >= self.length:
print 'error: out of index'
return
j \= 0
node \= self.head
while node.\_next and j < index:
node \= node.\_next
j += 1
if j == index:
node.data \= data
查找一个节点: getItem()
def getItem(self, index):
if self.isEmpty() or index < 0 or index >= self.length:
print "error: out of index"
return
j \= 0
node \= self.head
while node.\_next and j < index:
node \= node.\_next
j += 1
return node.data
查找一个节点的索引: getIndex()
def getIndex(self, data):
j \= 0
if self.isEmpty():
print "this chain table is empty"
return
node \= self.head
while node:
if node.data == data:
return j
node \= node.\_next
j += 1
if j == self.length:
print "%s not found" % str(data)
return
插入一个节点: insert()
def insert(self, index, dataOrNode):
if self.isEmpty():
print "this chain tabale is empty"
return
if index < 0 or index >= self.length:
print "error: out of index"
return
item \= None
if isinstance(dataOrNode, Node):
item \= dataOrNode
else:
item \= Node(dataOrNode)
if index == 0:
item.\_next \= self.head
self.head \= item
self.length += 1
return
j \= 0
node \= self.head
prev \= self.head
while node.\_next and j < index:
prev \= node
node \= node.\_next
j += 1
if j == index:
item.\_next \= node
prev.\_next \= item
self.length += 1
清空链表: clear()
def clear(self):
self.head \= None
self.length \= 0
以上就是链表类的要实现的方法。
执行的结果：
接下来是完整代码：
1 # -\*- coding:utf8 -\*-
2 #/usr/bin/env python
3
4 class Node(object): 5 def \_\_init\_\_(self, data, pnext = None): 6 self.data = data 7 self.\_next = pnext 8
9 def \_\_repr\_\_(self):
10 return str(self.data) 11
12 class ChainTable(object): 13 def \_\_init\_\_(self):
14 self.head = None 15 self.length = 0 16
17 def isEmpty(self): 18 return (self.length == 0) 19
20 def append(self, dataOrNode): 21 item = None 22 if isinstance(dataOrNode, Node): 23 item = dataOrNode 24 else:
25 item = Node(dataOrNode) 26
27 if not self.head: 28 self.head = item 29 self.length += 1
30
31 else:
32 node = self.head 33 while node.\_next: 34 node = node.\_next 35 node.\_next = item 36 self.length += 1
37
38 def delete(self, index): 39 if self.isEmpty(): 40 print "this chain table is empty."
41 return
42
43 if index < 0 or index >= self.length: 44 print 'error: out of index'
45 return
46
47 if index == 0: 48 self.head = self.head.\_next 49 self.length -= 1
50 return
51
52 j = 0 53 node = self.head 54 prev = self.head 55 while node.\_next and j < index: 56 prev = node 57 node = node.\_next 58 j += 1
59
60 if j == index: 61 prev.\_next = node.\_next 62 self.length -= 1
63
64 def insert(self, index, dataOrNode): 65 if self.isEmpty(): 66 print "this chain tabale is empty"
67 return
68
69 if index < 0 or index >= self.length: 70 print "error: out of index"
71 return
72
73 item = None 74 if isinstance(dataOrNode, Node): 75 item = dataOrNode 76 else:
77 item = Node(dataOrNode) 78
79 if index == 0: 80 item.\_next = self.head 81 self.head = item 82 self.length += 1
83 return
84
85 j = 0 86 node = self.head 87 prev = self.head 88 while node.\_next and j < index: 89 prev = node 90 node = node.\_next 91 j += 1
92
93 if j == index: 94 item.\_next = node 95 prev.\_next = item 96 self.length += 1
97
98 def update(self, index, data): 99 if self.isEmpty() or index < 0 or index >= self.length:
100 print 'error: out of index'
101 return
102 j = 0
103 node = self.head
104 while node.\_next and j < index:
105 node = node.\_next
106 j += 1
107
108 if j == index:
109 node.data = data
110
111 def getItem(self, index):
112 if self.isEmpty() or index < 0 or index >= self.length:
113 print "error: out of index"
114 return
115 j = 0
116 node = self.head
117 while node.\_next and j < index:
118 node = node.\_next
119 j += 1
120
121 return node.data
122
123
124 def getIndex(self, data):
125 j = 0
126 if self.isEmpty():
127 print "this chain table is empty"
128 return
129 node = self.head
130 while node:
131 if node.data == data:
132 return j
133 node = node.\_next
134 j += 1
135
136 if j == self.length:
137 print "%s not found" % str(data)
138 return
139
140 def clear(self):
141 self.head = None
142 self.length = 0
143
144 def \_\_repr\_\_(self):
145 if self.isEmpty():
146 return "empty chain table"
147 node = self.head
148 nlist = ''
149 while node:
150 nlist += str(node.data) + ' '
151 node = node.\_next
152 return nlist
153
154 def \_\_getitem\_\_(self, ind):
155 if self.isEmpty() or ind < 0 or ind >= self.length:
156 print "error: out of index"
157 return
158 return self.getItem(ind)
159
160 def \_\_setitem\_\_(self, ind, val):
161 if self.isEmpty() or ind < 0 or ind >= self.length:
162 print "error: out of index"
163 return
164 self.update(ind, val)
165
166 def \_\_len\_\_(self):
167 return self.length
python链表
168
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
