用Python实现链表---单向循环链表

分析

单向循环链表

add方法：向链表的头部添加一个节点 data

append方法：向链表的尾部添加一个节点， 值为data

remove方法：删除链表中第一个值为data的节点

代码

class Node:  # 链表的节点类
    def __init__(self, data, _next=None):
        self.data = data  # 数据域
        self.next = _next  # 指针域

class SingleCycleLinkList:
    def __init__(self):
        self.head = None  # 头结点
        self._length = 0  # 长度

    def is_empty(self):
        #链表是否为空
        return self._length == 0

    def length(self):
        # 链表长度
        return self._length

    def nodes_list(self):
        # 返回链表中的所有节点的值组成的列表
        ls = []
        if self.is_empty():#链表为空
            return ls
        else:#链表非空
            ls.append(self.head.data)#一开始就先加入头节点的值
            cur = self.head.next # cur从第二个节点开始  当cur==head时即
            while cur != self.head:  # cur = self.head时转了一圈找到头结点
                ls.append(cur.data)
                cur = cur.next  # 链表不为空时继续向后
            return ls  # 返回链表

    def add(self, data):
        # 向链表的头部添加一个节点 data
        # 链表的尾节点需要指向新增的节点
        node = Node(data)  # 新建一个节点
        if self.is_empty():#链表为空
            self.head = node
            node.next = node #新节点既是头结点又是尾节点 自己指向自己  或者 node.next = self.head
        else:#不为空
            node.next = self.head  #  先让node指向当前链表中的头结点

            #让链表的尾节点的next指向新增的节点
            #先找到尾节点
            cur = self.head
            while cur.next != self.head:# cur.next == self.head时找到尾节点
                cur = cur.next
            cur.next = node #让链表的尾节点的next指向新增的节点
            self.head = node  # 再让链表的head指向当前node节点
        self._length += 1  # 添加节点 链表长度+1

    def append(self, data):
        # 向链表的尾部添加一个节点， 值为data
        # 新建一个节点node, 值为data
        node = Node(data)
        if self.head != None:  # 链表不为空 有元素
            # 找到链表的尾节点
            cur = self.head
            while cur.next != self.head:  # cur.next == self.head时找到尾节点
                cur = cur.next
            # 让当前的尾节点得指针域指向node
            cur.next = node
            node.next = self.head

        else:  # 空链表
            self.head = node
            node.next = node  # 新节点既是头结点又是尾节点 自己指向自己  或者 node.next = self.head
        self._length += 1 # 添加完毕，链表的长度+1

    def insert(self, pos, data):
        # 向指定位置添加节点，值为data
        # 异常情况 超出边界
        if pos <= 0:
            self.add(data)
        elif pos >= self._length:
            self.append(data)
        else:
            node = Node(data)  # 1
            cur = self.head
            n = 0  # 2找链表中索引为pos-1的节点（0,1,2）， cur = cur.next 执行pos-1步
            while n < pos - 1:
                cur = cur.next
                n = n + 1
            # 到这里cur指向的是索引为pos-1 的节点
            node.next = cur.next  # 3 cur.next 为pos的节点
            cur.next = node  # 4 让索引为pos-1的节点得next指向node
            self._length += 1  # 5 长度+1

    def remove(self, data):
        # 删除链表中第一个值为data的节点
        if self.is_empty():
            return -1 #链表为空，无法删除
        else:
            cur = self.head
            flag = True #标志位的作用是让第一个节点能进入循环
            prev = None  # 要删除节点得前驱节点
            while cur != self.head or flag:#保证第一个节点能进入循环
                flag = False#让循环集训的条件 必须是cur != self.head
                if cur.data == data:
                    if prev == None: # 要删除的是第一个节点时    # 如果前驱节点为空， 说明我们要删除的节点是第一个节点
                        # 找到链表的尾节点
                        last_node = self.head
                        while last_node.next != self.head:  # last_node.next == self.head时找到尾节点
                            last_node = last_node.next
                        # 循环结束后，此时的last_node指向链表的最后一个节点
                        last_node.next = self.head.next # 找到尾节点 让尾节点的next指针指向第二个节点
                        self.head = self.head.next#  此时self.head.next相当于cur.next
                    else:  # 要删除的不是第一个节点
                        prev.next = cur.next
                    self._length -= 1
                    return 0  # 找到
                prev = cur
                cur = cur.next  # 继续向后
            return -1  # 没有找到

    def modify(self, pos, data):
        # 修改链表中指定位置元素的值
        if pos < 0 or pos >= self._length:
            print("位置不正确")  # 位置不正确
        else:
            cur = self.head
            n = 0  # 找链表中索引为pos的节点（0,1,2）， cur = cur.next 执行pos-1步
            while n < pos:
                cur = cur.next
                n = n + 1
            cur.data = data

    def search(self, data):
        # 查找链表中是否有节点的值为data
        if self.is_empty():
            return False
        else:
            cur = self.head
            flag = True  # 标致我的作用是让第一个节点能进入循环
            while cur != self.head or flag:  # 保证第一个节点能进入循环
                flag = False  # 让循环集训的条件 必须是cur != self.head
                if cur.data == data:
                    return True  # 找到
                cur = cur.next  # 继续向后
            return False  # 没有找到

if __name__ == "__main__":
    l1 = SingleCycleLinkList()  # 新建一个链表类
    print(l1.head, l1.length())  # 测试None 0

    l1.add(1)
    print(l1.nodes_list())

    l1.add(2)
    print(l1.nodes_list())

    print(l1.head.data, l1.head.next.data, l1.head.next.next.data)

    l1.append(4)
    print(l1.nodes_list())

    l1.insert(1, 7)
    print(l1.nodes_list())


    l1.remove(2)
    print(l1.nodes_list())

    l1.modify(1, 3)
    print(l1.nodes_list())

    print("查找")
    print(l1.search(3))

结果