包含节点数目的单链表的实现代码

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)
包含节点数目的单链表的实现代码

猜你喜欢
