.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 實現一個全面的單鏈表