Python 實現一個全面的單鏈表
阿新 • • 發佈：2019-01-26
.com ins 可重復 name ews 靈活 parse 就是 open
文章目錄
- 前言
- 實現清單
- 鏈表實現
- 更新
- 總結
前言
算法和數據結構是一個亙古不變的話題，作為一個程序員，掌握常用的數據結構實現是非常非常的有必要的。
實現清單
實現鏈表，本質上和語言是無關的。但是靈活度卻和實現它的語言密切相關。今天用Python來實現一下，包含如下操作：
[‘addNode(self, data)‘] [‘append(self, value)‘] [‘prepend(self, value)‘] [‘insert(self, index, value)‘] [‘delNode(self, index)‘] [‘delValue(self, value)‘] [‘isempty(self)‘] [‘truncate(self)‘] [‘getvalue(self, index)‘] [‘peek(self)‘] [‘pop(self)‘] [‘reverse(self)‘] [‘delDuplecate(self)‘] [‘updateNode(self, index, value)‘] [‘size(self)‘] [‘print(self)‘]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
生成這樣的一個方法清單肯定是不能手動寫了，要不然得多麻煩啊，於是我寫了個程序，來匹配這些自己實現的方法。代碼比較簡單，核心思路就是匹配源文件的每一行，找到符合匹配規則的內容，並添加到總的結果集中。
代碼如下：
# coding: utf8 # @Author: 郭 璞 # @File: getmethods.py # @Time: 2017/4/5 # @Contact: [email protected] # @blog: http://blog.csdn.net/marksinoberg # @Description: 獲取一個模塊或者類中的所有方法及參數列表 import re def parse(filepath, repattern): with open(filepath, ‘rb‘) as f: lines = f.readlines() # 預解析正則 rep = re.compile(repattern) # 創建保存方法和參數列表的結果集列表 result = [] # 開始正式的匹配實現 for line in lines: res = re.findall(rep, str(line)) print("{}的匹配結果{}".format(str(line), res)) if len(res)!=0 or res is not None: result.append(res) else: continue return [item for item in result if item !=[]] if __name__ == ‘__main__‘: repattern = "def (.[^_0-9]+\(.*?\)):" filepath = ‘./SingleChain.py‘ result = parse(filepath, repattern) for item in result: print(str(item))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
鏈表實現
# coding: utf8 # @Author: 郭 璞 # @File: SingleChain.py # @Time: 2017/4/5 # @Contact: [email protected] # @blog: http://blog.csdn.net/marksinoberg # @Description: 單鏈表實現 class Node(object): def __init__(self, data, next): self.data = data self.next = next class LianBiao(object): def __init__(self): self.root = None # 給單鏈表添加元素節點 def addNode(self, data): if self.root==None: self.root = Node(data=data, next=None) return self.root else: # 有頭結點，則需要遍歷到尾部節點，進行鏈表增加操作 cursor = self.root while cursor.next!= None: cursor = cursor.next cursor.next = Node(data=data, next=None) return self.root # 在鏈表的尾部添加新節點，底層調用addNode方法即可 def append(self, value): self.addNode(data=value) # 在鏈表首部添加節點 def prepend(self, value): if self.root == None: self.root = Node(value, None) else: newroot = Node(value, None) # 更新root索引 newroot.next = self.root self.root = newroot # 在鏈表的指定位置添加節點 def insert(self, index, value): if self.root == None: return if index<=0 or index >self.size(): print(‘index %d 非法， 應該審視一下您的插入節點在整個鏈表的位置！‘) return elif index==1: # 如果index==1， 則在鏈表首部添加即可 self.prepend(value) elif index == self.size()+1: # 如果index正好比當前鏈表長度大一，則添加在尾部即可 self.append(value) else: # 如此，在鏈表中部添加新節點，直接進行添加即可。需要使用計數器來維護插入未知 counter = 2 pre = self.root cursor = self.root.next while cursor!=None: if counter == index: temp = Node(value, None) pre.next = temp temp.next = cursor break else: counter += 1 pre = cursor cursor = cursor.next # 刪除指定位置上的節點 def delNode(self, index): if self.root == None: return if index<=0 or index > self.size(): return # 對第一個位置需要小心處理 if index == 1: self.root = self.root.next else: pre = self.root cursor = pre.next counter = 2 while cursor!= None: if index == counter: print(‘can be here!‘) pre.next = cursor.next break else: pre = cursor cursor = cursor.next counter += 1 # 刪除值為value的鏈表節點元素 def delValue(self, value): if self.root == None: return # 對第一個位置需要小心處理 if self.root.data == value: self.root = self.root.next else: pre = self.root cursor = pre.next while cursor!=None: if cursor.data == value: pre.next = cursor.next # 千萬記得更新這個節點，否則會出現死循環。。。 cursor = cursor.next continue else: pre = cursor cursor = cursor.next # 判斷鏈表是否為空 def isempty(self): if self.root == None or self.size()==0: return True else: return False # 刪除鏈表及其內部所有元素 def truncate(self): if self.root == None or self.size()==0: return else: cursor = self.root while cursor!= None: cursor.data = None cursor = cursor.next self.root = None cursor = None # 獲取指定位置的節點的值 def getvalue(self, index): if self.root is None or self.size()==0: print(‘當前鏈表為空！‘) return None if index<=0 or index>self.size(): print("index %d不合法！"%index) return None else: counter = 1 cursor = self.root while cursor is not None: if index == counter: return cursor.data else: counter += 1 cursor = cursor.next # 獲取鏈表尾部的值，且不刪除該尾部節點 def peek(self): return self.getvalue(self.size()) # 獲取鏈表尾部節點的值，並刪除該尾部節點 def pop(self): if self.root is None or self.size()==0: print(‘當前鏈表已經為空！‘) return None elif self.size()==1: top = self.root.data self.root = None return top else: pre = self.root cursor = pre.next while cursor.next is not None: pre = cursor cursor = cursor.next top = cursor.data cursor = None pre.next = None return top # 單鏈表逆序實現 def reverse(self): if self.root is None: return if self.size()==1: return else: # post = None pre = None cursor = self.root while cursor is not None: # print(‘逆序操作逆序操作‘) post = cursor.next cursor.next = pre pre = cursor cursor = post # 千萬不要忘記了把逆序後的頭結點賦值給root，否則無法正確顯示 self.root = pre # 刪除鏈表中的重復元素 def delDuplecate(self): # 使用一個map來存放即可，類似於變形的“桶排序” dic = {} if self.root == None: return if self.size() == 1: return pre = self.root cursor = pre.next dic = {} # 為字典賦值 temp = self.root while temp!=None: dic[str(temp.data)] = 0 temp = temp.next temp = None # 開始實施刪除重復元素的操作 while cursor!=None: if dic[str(cursor.data)] == 1: pre.next = cursor.next cursor = cursor.next else: dic[str(cursor.data)] += 1 pre = cursor cursor = cursor.next # 修改指定位置節點的值 def updateNode(self, index, value): if self.root == None: return if index<0 or index>self.size(): return if index == 1: self.root.data = value return else: cursor = self.root.next counter = 2 while cursor!=None: if counter == index: cursor.data = value break cursor = cursor.next counter += 1 # 獲取單鏈表的大小 def size(self): counter = 0 if self.root == None: return counter else: cursor = self.root while cursor!=None: counter +=1 cursor = cursor.next return counter # 打印鏈表自身元素 def print(self): if(self.root==None): return else: cursor = self.root while cursor!=None: print(cursor.data, end=‘\t‘) cursor = cursor.next print() if __name__ == ‘__main__‘: # 創建一個鏈表對象 lianbiao = LianBiao() # 判斷當前鏈表是否為空 print("鏈表為空%d"%lianbiao.isempty()) # 判斷當前鏈表是否為空 lianbiao.addNode(1) print("鏈表為空%d"%lianbiao.isempty()) # 添加一些節點，方便操作 lianbiao.addNode(2) lianbiao.addNode(3) lianbiao.addNode(4) lianbiao.addNode(6) lianbiao.addNode(5) lianbiao.addNode(6) lianbiao.addNode(7) lianbiao.addNode(3) # 打印當前鏈表所有值 print(‘打印當前鏈表所有值‘) lianbiao.print() # 測試對鏈表求size的操作 print("鏈表的size: "+str(lianbiao.size())) # 測試指定位置節點值的獲取 print(‘測試指定位置節點值的獲取‘) print(lianbiao.getvalue(1)) print(lianbiao.getvalue(lianbiao.size())) print(lianbiao.getvalue(7)) # 測試刪除鏈表中指定值， 可重復性刪除 print(‘測試刪除鏈表中指定值， 可重復性刪除‘) lianbiao.delNode(4) lianbiao.print() lianbiao.delValue(3) lianbiao.print() # 去除鏈表中的重復元素 print(‘去除鏈表中的重復元素‘) lianbiao.delDuplecate() lianbiao.print() # 指定位置的鏈表元素的更新測試 print(‘指定位置的鏈表元素的更新測試‘) lianbiao.updateNode(6, 99) lianbiao.print() # 測試在鏈表首部添加節點 print(‘測試在鏈表首部添加節點‘) lianbiao.prepend(77) lianbiao.prepend(108) lianbiao.print() # 測試在鏈表尾部添加節點 print(‘測試在鏈表尾部添加節點‘) lianbiao.append(99) lianbiao.append(100) lianbiao.print() # 測試指定下標的插入操作 print(‘測試指定下標的插入操作‘) lianbiao.insert(1, 10010) lianbiao.insert(3, 333) lianbiao.insert(lianbiao.size(), 99999) lianbiao.print() # 測試peek 操作 print(‘測試peek 操作‘) print(lianbiao.peek()) lianbiao.print() # 測試pop 操作 print(‘測試pop 操作‘) print(lianbiao.pop()) lianbiao.print() # 測試單鏈表的逆序輸出 print(‘測試單鏈表的逆序輸出‘) lianbiao.reverse() lianbiao.print() # 測試鏈表的truncate操作 print(‘測試鏈表的truncate操作‘) lianbiao.truncate() lianbiao.print()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
- 280
- 281
- 282
- 283
- 284
- 285
- 286
- 287
- 288
- 289
- 290
- 291
- 292
- 293
- 294
- 295
- 296
- 297
- 298
- 299
- 300
- 301
- 302
- 303
- 304
- 305
- 306
- 307
- 308
- 309
- 310
- 311
- 312
- 313
- 314
- 315
- 316
- 317
- 318
- 319
- 320
- 321
- 322
- 323
- 324
- 325
- 326
- 327
- 328
- 329
- 330
- 331
- 332
- 333
- 334
- 335
- 336
- 337
- 338
- 339
- 340
- 341
- 342
- 343
- 344
- 345
- 346
代碼運行的結果如何呢？是否能滿足我們的需求，且看打印的結果:
D:\Software\Python3\python.exe E:/Code/Python/Python3/CommonTest/datastructor/SingleChain.py
鏈表為空1
鏈表為空0
打印當前鏈表所有值
1 2 3 4 6 5 6 7 3
鏈表的size: 9
測試指定位置節點值的獲取
1
3
6
測試刪除鏈表中指定值， 可重復性刪除
can be here!
1 2 3 6 5 6 7 3
1 2 6 5 6 7
去除鏈表中的重復元素
1 2 6 5 7
指定位置的鏈表元素的更新測試
1 2 6 5 7
測試在鏈表首部添加節點
108 77 1 2 6 5 7
測試在鏈表尾部添加節點
108 77 1 2 6 5 7 99 100
測試指定下標的插入操作
10010 108 333 77 1 2 6 5 7 99 99999 100
測試peek 操作
100
10010 108 333 77 1 2 6 5 7 99 99999 100
測試pop 操作
100
10010 108 333 77 1 2 6 5 7 99 99999
測試單鏈表的逆序輸出
99999 99 7 5 6 2 1 77 333 108 10010
測試鏈表的truncate操作
Process finished with exit code 0
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
剛好實現了目標需求。
更新
看到有評論說刪除重復節點的代碼有點問題，那麽今天（2018年11月29日21:18:24）再來更新一下，另外加上點chain的支持。
#coding: utf8
__author__ = "郭 璞"
__email__ = "[email protected]"
# 鏈表
class Node(object):
def __init__(self, data, next):
self.data = data
self.next = next
class Chain(object):
def __init__(self):
self.root = None
self.length = 0
def printself(self):
if self.root == None:
return
else:
cursor = self.root
counter = 0
while cursor != None:
print("index: {}, value: {}".format(counter, cursor.data))
cursor = cursor.next
counter += 1
print("self-print end.")
def _addNode(self, data):
if self.root == None:
self.root = Node(data=data, next=None)
else:
cursor = self.root
while cursor.next != None:
cursor = cursor.next
cursor.next = Node(data=data, next=None)
self.length += 1
return self.root
def append(self, data):
self._addNode(data=data)
return self
def prepend(self, data):
if self.root == None:
self.root = Node(data=data, next=None)
else:
node = Node(data=data, next=self.root)
self.root = node
self.length += 1
return self
def size(self):
return self.length
def insert(self, index, data):
if index < 0 :
self.prepend(data)
if index == 0 and self.root == None:
self.root = Node(data=data, next=None)
elif index == 1 and self.size() == 1:
self.prepend(data)
elif index > 1 and index < self.size():
counter = 1
pre = self.root
cursor = self.root.next
while cursor != None:
if counter == index:
pre.next = Node(data=data, next=cursor)
break;
else:
counter += 1
pre = cursor
cursor = cursor.next
elif index > self.size():
self.append(data)
self.length += 1
return self
def isempty(self):
return self.length == 0
def update(self, index, newdata):
if self.root == None:
return
if index < 0:
return
elif index < self.size():
cursor = self.root
counter = 0
while cursor!= None:
if counter == index:
cursor.data = newdata
break
else:
cursor = cursor.next
counter += 1
else:
return
return self
def remove(self, index):
if self.root == None:
return
if index < 0 or index > self.size():
raise IndexError("index out of boundary.")
if self.size() == 1 and index==0:
self.root = None
elif index==0 and self.size() > 1:
self.root = self.root.next
elif index > 0 and index < self.size():
pre = self.root
cursor = self.root.next
counter = 1
while cursor != None:
if counter == index:
pre.next = cursor.next
break
else:
counter += 1
pre = cursor
cursor = cursor.next
self.length -= 1
return self
def delete(self, data):
if self.root == None:
return
if self.size() == 1:
if self.root.data == data:
self.root = None
self.length -= 1
return
else:
# 鏈表長度大於1 看看是否為頭結點，要區分對待
if self.root.data == data:
self.root = self.root.next
self.length -= 1
else:
pre = self.root
cursor = self.root.next
while cursor != None:
if cursor.data == data:
pre.next = cursor.next
# 很關鍵的一步，否則可能出現死循環
cursor = cursor.next
self.length -= 1
else:
pre = cursor
cursor = cursor.next
return self
def get(self, index):
ret = None
if self.root == None:
return ret
if index < 0:
return ret
elif index < self.size():
counter = 0
cursor = self.root
ret = None
while cursor!= None:
if counter == index:
ret = cursor.data
break
else:
counter += 1
cursor = cursor.next
else:
pass
return ret
def reverse(self):
if self.root == None:
return
if self.size() == 1:
return self
else:
pre = None
cursor = self.root
post = self.root.next
while cursor != None:
post = cursor.next
cursor.next = pre
pre = cursor
cursor = post
# 至關重要的一步操作
self.root = pre
return self
if __name__ == "__main__":
chain = Chain()
chain.append(0).append(1).append(2).append(3).append(4)
# chain.prepend(9)
# chain.insert(2, 999)
# chain.update(4, 1000)
# chain.printself()
# chain.remove(1)
# chain.printself()
# chain.delete(111)
# chain.printself()
# print(chain.get(100))
chain.reverse()
chain.printself()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
總結
今天的內容還是比較基礎，也沒什麽難點。但是看懂和會寫還是兩碼事，沒事的時候寫寫這樣的代碼還是很有收獲的。
再分享一下我老師大神的人工智能教程吧。零基礎！通俗易懂！風趣幽默！還帶黃段子！希望你也加入到我們人工智能的隊伍中來！https://blog.csdn.net/jiangjunshow
Python 實現一個全面的單鏈表