Python单向循环链表

一、单向循环链表定义
单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。

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

二、代码实现

class Node(object):
    """节点"""
    def __init__(self,item):  #定义的数据域和指针域
        self.elem=item
        self.next=None


class SingleLinkLink(object):
    """单向循环链表"""
    def __init__(self,node=None):   #头节点为私有属性，加上下划线,用来指向第一个节点
        self.__head=node   #头结点 指向用户传进来的node
        if node:
            node.next = node

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

    def length(self):    #链表长度
        if self.is_empty() :
            return 0
        p = self._head  # p来移动遍历节点
        count = 1
        while p.next != self._head :  #如果循环条件是p.next!=None，那么到进行到最后一个节点是就不满足条件退出，count没法计数
            count += 1
            p = p.next
        return count

    def travel(self):
        if self.is_empty():
            return 0
        p = self.__head
        while p.next != self.__head:
            print(p.elem)
            p = p.next
        # 退出循环时，cur正是尾节点
        print(p.elem)

    def add(self, item):   #向头部增加节点
        node=Node(item)
        if self.is_empty() :
            self.__head = node
            node.next = node
        else:
            p = self.__head
            while p.next != self.__head:
                p = p.next
                node.next = self.__head
                self.__head = node
                p.next = node

    def append(self,item):   #向尾部增加节点
        node = Node(item)
        if self.is_empty():
            self.__head=node
            node.next = node
        else:
            p = self.__head
            while(p.next != self.__head):
                p = p.next
            #找到尾结点，退出循环，进行尾部插入
            p.next = node
            node.next = self.__head
    def insert(self,pos,item): #向任意位置增加节点
        if pos<=0:
            self.add(item)
        elif pos>(self.length()-1):
            self.append(item)
        else:
            pre = self.__head
            node = Node(item)
            count = 0
            while (count < (pos - 1)):
                pre = pre.next
                count += 1
                # 当循环结束后，pre指向pos-1的位置
                node.next = pre.next
                pre.next = node


    def remove(self,item):    #删除某个节点\
        if self.is_empty() :
            return False
        pre=None
        p=self.__head
        while(p.next != self.__head):  #保证每一个结点都遍历完
            if p.elem == item:
                if p == self.__head:
                    #先判断此结点是否是头结点
                    #找尾结点
                    rear = self.__head
                    while rear.next != self.__head:
                        rear = rear.next
                        self.__head = p.next
                        rear.next = self.__head
                else:
                    #中间结点
                    pre.next = p.next
                return
            else:
                pre = p
                p = p.next
        #退出循环
        if p.elem == item:
            if p == self.__head:
                #链表只有一个节点
                self.__head = None
            else:
                pre.next = p.next


    def search(self, item):
        """链表查找节点是否存在，并返回True或者False"""
        if self.is_empty() :
            return False
        p = self.__head
        while p.next != self.__head:
            if p.elem == item:
                return True
            else:
                p=p.next
        #如果指向p指向尾结点，退出循环
        if p.elem==item:
            return True
        return False