单向循环链表

单向循环链表和单向链表的唯一区别是末节点的next指向是头节点的内存地址。

现在再次实现单向循环链表的一系列功能：

is_empty() 链表是否为空
length() 链表长度
travel() 遍历整个链表
add(item) 链表头部添加元素
append(item) 链表尾部添加元素
insert(pos, item) 指定位置添加元素
remove(item) 删除节点
search(item) 查找节点是否存在

class Node:  # 元素
    def __init__(self, elem):
        self.elem = elem  # 此节点的数值
        self.next = None  # 下一个节点的内存地址


class SingleLinkList:  # 单向循环链表
    def __init__(self, node=None):
        self.__head = node#链表如果初始化后有一个节点，则此节点为头节点，此节点的next指向自己
        if node:
            node.next = node

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

    def length(self):  # 链表长度
        # 要考虑到链表为空的情况
        if self.is_empty():
            count = 0
        else:
            count = 1
            cur = self.__head  # 游标
            while cur.next != self.__head:
                count += 1
                cur = cur.next
        return count

    def travel(self):  # 遍历整个链表
        if self.is_empty():
            return
        cur = self.__head  # 游标
        while cur.next != self.__head:#退出循环，cur指向尾节点，但是尾节点的元素没有打印
            print(cur.elem, end=" ")
            cur = cur.next
        print(cur.elem)#打印尾节点

    def add(self, item):  # 链表头部添加元素
        node = Node(item)#先要把尾节点的next指向头节点
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            node.next = self.__head
            self.__head = node
            cur.next = self.__head


    def append(self, item):  # 链表尾部添加元素 item为数据，不是节点，让用户使用起来方便，只要用户输入数字
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            cur.next = node
            node.next = self.__head

    def insert(self, pos, item):  # 指定位置添加元素
        count = 0
        cur = self.__head
        if pos <= 0:
            self.add(item)
        elif pos > self.length() - 1:
            self.append(item)
        else:
            while count < pos - 1:  # 在指定位置的前一个节点，插入新的节点，
                cur = cur.next  # 游标指向下一个
                count += 1
            node = Node(item)
            node.next = cur.next  # 新的节点的下一个节点指向原来位置为pos的节点
            cur.next = node  # 然后在把游标的下一个节点指向要插入的节点，要注意先后顺序

    def remove(self, item):  # 删除节点
        if self.is_empty():
            return
        cur = self.__head  # 游标在第一个节点
        prev = None  # 此时游标的上一个位置为None
        while cur.next != self.__head:
            if cur.elem == item:  # 找到要删除逇数字
                if cur == self.__head:  # 如果要删除的节点为第一个节点
                    rear = self.__head
                    while rear.next != self.__head:
                        rear = rear.next
                    self.__head = cur.next
                    rear.next = self.__head
                else:#中间节点
                    prev.next = cur.next # 其余情况下则把要删除节点的上一个节点指向下一个节点
                return
            else:
                prev = cur
                cur = cur.next
        if cur.elem == item:
            if cur == self.__head:
                self.__head = None
            else:
                prev.next = cur.next#尾节点

    def search(self, item):  # 查找节点是否存在
        if self.is_empty():
            return False
        cur = self.__head  # 游标
        while cur.next != self.__head:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        if cur.elem == item:
            return True
        return False


if __name__ == '__main__':
    sll = SingleLinkList()
    print("是否为空", sll.is_empty())
    print("链表长度", sll.length())
    sll.append(1)
    sll.append(2)
    sll.append(3)
    sll.append(4)
    sll.travel()
    sll.remove(4)
    sll.travel()
    sll.remove(3)
    sll.travel()