python ：循环链表的实现

#循环链表

• 表中最后一个结点的指针域指向头结点，整个链表形成一个环

#单向循环链表的实现

• 初始化节点类，初始化头结点

    class Node :
        def __init__(self,data,next = None):   #节点类
            self.data = data
            self.next = next
    def __init__(self,node = None):
        self._point = node
        self._size = 0

• 链表的长度，以及判断是否为空

    def lengeth(self):
        return self._size
    def is_empty(self):
        if not self._size == 0:
            return False
        return True

• 得到链表的元素

#得到整个链表的所有元素
  def get_list(self):
        if self.is_empty() :
            return False
        else :
        '''
        遍历到头部节点的前驱节点
        '''
            cur = self._point
            print(self._point.data,end=" ")
            while cur.next != self._point :
                cur = cur.next
                print(cur.data, end=" ")
#得到指定的索引的元素
    def get_insert(self,pros):
        if self.is_empty() :
            return False
        cur = self._point
        count = 0
        while count < pros :
            cur = cur.next
            count += 1
        return cur.data

• 添加元素

    def NonePoint(self,node):
        node.next = node
        self._point = node
    def add_first(self,element):
        node = self.Node(element)
        if self.is_empty() :
            #创建一个节点的环
            self.NonePoint(node)
        else :
            cur = self._point
            while cur.next != self._point :
                cur = cur.next
            '''
            新节点的后继为_point > 新节点的值赋给_point > cur节点的直接后继为_point
            '''
            node.next = self._point       #创建新节点的指针
            self._point = node             #头结点的位置
            cur.next = self._point
        self._size += 1
    def add_last(self,element):     #清除链表中的最后一个元素
        node =self.Node(element)
        if self.is_empty() :
            self.NonePoint(node)
        else :
            cur = self._point
            while cur.next != self._point:
                cur = cur.next
            node.next = cur.next   #将链表的最后一个节点的“next”赋给node.next
            cur.next = node
        self._size += 1
    def insert_elemenr(self,pros,element):
        node = self.Node(element)
        if self.is_empty() :
            self.NonePoint(node)
        else :
            count,cur = 0,self._point
            while count < pros :
                if count == -1 :
                    self.add_first(element)
                    break
                elif count == pros -1 :
                '''
                cur的直接后继赋给新节点的直接后继 > 新节点赋给cur的直接后继
                '''
                    node.next = cur.next
                    cur.next = node
                    break
                cur = cur.next
                count += 1
        self._size += 1

• 删除元素

 def del_first(self):    #清除链表中的第一个元素
        if not self.is_empty() :
            cur = self._point
            while cur.next!= self._point :
                cur = cur.next
            self._point = self._point.next
            cur.next = self._point
            self._size -= 1
        return False
    def del_last(self):      #清除链表中的最后一个元素
        if not self.is_empty() :
            cur = self._point
            while cur.next.next!= self._point :
                cur = cur.next
            cur.next = cur.next.next
            self._size -= 1
        return False
    def del_insert(self,pros):     #清除指定的元素
        if not self.is_empty() or pros < 0 or pros > self._size-1:
            cur = self._point
            count = 0
            if pros == 0 :
                self.del_first()
            while count < pros:
                if count == pros - 1:
                    cur.next = cur.next.next
                    break
                count += 1
                cur = cur.next
        self._size -= 1
        return False
    def del_all(self):             #清除所有元素
        if not self.is_empty() :
            self._point.next = None
        self._size = 0
        return True