27_Python单向循环链表的封装与实现

一、概述
单向循环链表是指在单链表的基础上，表的最后一个元素指向链表头结点，不再是为空。

由图可知，单向循环列表的判断条件不再是表为空了，而变成了是否到表头。

二、操作功能
is_empty() #判断链表是否为空
length() #返回链表长度
travel() #遍历
add(item) #在头部添加一个节点
append(item) #在尾部添加一个节点
insert(pos,item) #在指定位置pos添加节点
remove(item) #删除一个节点
search(item) #查找节点是否存在

三、代码封装实现

class Node(object):
    """节点"""
    def __init__(self,item):
        self.item =item
        self.next =None

class SinCycLinkedList(object):
    """单循环链表"""
    def __init__(self):
        self.head =None

    def is_empty(self):
        """判断链表是否为空"""
        return self.head == None

    def lenght(self):
        """返回链表的长度
        如果链表长度为空，返回长度为0"""
        if self.is_empty():
            return 0
        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
        print(cur.item)
        while cur.next != self.head:
            cur =cur.next
            print(cur.item)


    def add(self,item):
        """头部添加节点"""
        node =Node(item)
        if self.is_empty():
            self.head=node
            node.next=self.head
        else:
            #添加的节点指向head
            node.next =self.head
            #移到链表尾部，将尾部节点的next 指向node
            cur =self.head
            while cur.next != self.head:
                cur =self.next
            cur.next =node
            #head 指向添加node
            self.head = node

    def append(self,item):
        """尾部添加节点"""
        node =Node(item)
        if self.is_empty():
            self.head =node
            node.next =self.head
        else:
            #移动链表尾部
            cur = self.head
            while cur.next != self.head:
                cur =cur.next
            #将尾节点指向node
            cur.next =node
            #将node指向头节点
            node.next =self.head

    def insert(self,pos,item):
        """在指定的位置添加节点"""
        if pos <=0:
            self.add(item)
        elif pos> (self.lenght() - 1):
            self.append(item)
        else:
            node =Node(item)
            cur =self.head
            count =0
            #移动到指定位置的前一个位置
            while count < (pos -1):
                count +=1
                cur =cur.next
            node.next =cur.next
            cur.next = node

    def remove(self,item):
        """删除一个节点"""
        #若链表为空，则直接返回
        if self.is_empty():
            return
        #将cur指向头节点
        cur =self.head
        pre =None
        #若头节点的元素就是要查找的元素item
        if cur.item == item:
            #如果链表不止一个节点
            if cur.next !=self.head:
                #先找到尾节点，将尾节点的next指向第二个节点
                while cur.next != self.head:
                    cur =cur.next
                #cur 指向了尾节点
                cur.next =self.head.next
                self.head =self.head.next
            else:
                #链表只有一个节点
                self.head =None
        else:
            pre= self.head
            #第一个节点不是要删除的
            while cur.next !=self.head:
                #找到了要删掉的元素
                if cur.item ==item:
                    #删除
                    pre.next =cur.next
                    return
                else:
                    pre =cur
                    cur =cur.next
            #cur指向尾节点
            if cur.item ==item:
                #删除尾部
                pre.next =cur.next

    def search(self,item):
        """查找节点是否存在"""
        if self.is_empty():
            return False
        cur =self.head
        if cur.item ==item:
            return True
        while cur.next != self.head:
            cur=cur.next
            if cur.item ==item:
                return True
        return False


if __name__ =="__main__":
    ll =SinCycLinkedList()
    ll.add(1)
    ll.add(2)
    ll.append(3)
    ll.insert(2,4)
    ll.insert(4,5)
    ll.insert(1,6)
    print("lenght:",ll.lenght(),ll.travel())