#迴圈連結串列

• 表中最後一個結點的指標域指向頭結點，整個連結串列形成一個環

#單向迴圈連結串列的實現

• 初始化節點類，初始化頭結點

    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