包含節點數目的單鏈表的實現代碼

class LNode:
    def __init__(self, elem, next=None):
        self.elem = elem
        self.next = next # 加個下劃線，爲了區分python中的next關鍵字

class listObj:
    def __init__(self):
        self.nodenum = 0
        self.head = None


# 這裏建立一個鏈表對象，其中還存儲了一個表示鏈表長度的nodenum屬性


# 建立一個頭節點
# Llist = LNode(1)
# p = Llist  # p作爲一個掃描指針，在掃描鏈表的時候不斷變化
#
# for i in range(2, 11):
#     p.next = LNode(i)
#     p = p.next
#
# p = Llist
# while p:
#     print(p.elem)
#     p = p.next
#
# # 對於一個鏈表，主要一、建立元素的鏈接關係；二、是要有到它的頭節點。

# 接下來是一個鏈表類的實現（意思是：支持鏈表的一些特定的操作）
class LinkedListUndeflow(ValueError):
    pass

class LList:
    # 建立一個空表
    def __init__(self):
        self.kehead = listObj()
        # 初始化一個鏈表對象,該鏈表對象存儲有鏈表的節點數和鏈表第一個節點的引用
        # head就是一個鏈表實例的屬性
    # 判斷鏈表是不是空，直接判斷鏈表的表頭是不是空就行了
    def isempty(self):
        return self.kehead.head is None

    # 接下來就是對元素的添加
    def prepend(self, elem): # 表頭插入
        self.kehead.head = LNode(elem, self.kehead.head)
        self.kehead.nodenum += 1

    # def append(self, elem): # 表尾插入
    #     if not self.head:
    #         self.head = LNode(elem)
    #     p = self.head # 掃描指針
    #     while p.next:
    #         p = p.next
    #     p.next = LNode(elem)
    def append(self, elem):
        p = self.kehead.head
        while p:
            if not p.next:
                p.next = LNode(elem)
                self.kehead.nodenum += 1
                return
            p = p.next
        p = LNode(elem)
        self.kehead.nodenum += 1

    def popfirst(self): # 表頭刪除，要求返回刪除元素
        if not self.kehead.head:
            raise LinkedListUndeflow("空表不可刪除")
        p = self.kehead.head
        self.kehead.head = p.next
        self.kehead.nodenum -= 1
        return p.elem

    def poplast(self): # 表尾刪除
        if not self.kehead.head:
            raise LinkedListUndeflow("空表不可刪除")
        if not self.kehead.head.next:
            e = self.kehead.head.elem
            self.kehead.head = None
            self.kehead.nodenum -= 1
            return e
        # 如果是有兩個及以上的元素，那麼將倒數第二個元素的next指向None就可以了
        # 所以要緊的是找到倒數第二個元素
        p = self.kehead.head
        while  p.next.next:
            p = p.next
        e = p.next.elem
        p.next = None
        self.kehead.nodenum -= 1
        return e
    def printall(self):
        # 是一個空鏈表，一個元素的鏈表，多個元素的鏈表
        p = self.kehead.head
        while p:
            print(p.elem, end = '')
            if p.next:
                print(',', end = '')
            p = p.next
        print("\n")

    def element(self):
        p = self.kehead.head
        while p:
            yield p.elem
            p = p.next
        # 利用生成器函數，生成一個迭代器（python中進行便利的工具）

mlist1 = LList() # 一個空的鏈表對象
print(mlist1.isempty())
for i in range(10):
    # 從首部加入是個元素
    mlist1.prepend(i)
print(mlist1.kehead.nodenum, "節點數", sep='--')
mlist1.printall()
# 看看首部加入是否成功
for i in range(10, 20):
    mlist1.append(i)
print(mlist1.kehead.nodenum, "節點數", sep='--')
mlist1.printall()

# 看看尾部加入是否成功
mlist1.popfirst()
print(mlist1.kehead.nodenum, "節點數", sep='--')
mlist1.printall()

# 看看首部刪除是否成功
mlist1.poplast()
print(mlist1.kehead.nodenum, "節點數", sep='--')
mlist1.printall()

# 看看尾部刪除是否成功
for i in mlist1.element():
    print(i)