单向循环列表

定义

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

操作

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

操作实现

#定义节点
class Node(object):
    def __init__(self, elem):
        self.elem = elem
        self.next = None

#单向循环链表类
class SingleCycleLinkList(object):
    def __init__(self, node=None):
        self.__head = node
        if node:
            node.next = node
	# 是否为空
	def is_empty(self):
	    return self.__head == None
	
	# 链表长度
	def length(self):
	    if self.is_empty():
	        return 0
	    # cur游标，用来移动遍历节点
	    cur = self.__head
	    # count记录数量
	    # 和单链表不同，count从1开始
	    count = 1  
	    while cur.next != self.__head:
	        count += 1
	        cur = cur.next
	    return count

	# 遍历链表
	def travel(self):
	    if self.is_empty():
	        return
	    # cur游标，用来移动遍历节点
	    cur = self.__head
	    # count记录数量
	    while cur.next != self.__head:
	        print(cur.elem, end=' ')
	        cur = cur.next
	    # 退出循环，cur指向尾节点，但尾节点未打印
	    print(cur.elem)
	
	# 表头添加元素,先寻找尾部节点
	def add(self, 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代表的是尾节点
	        node.next = self.__head
	        self.__head = node
	        cur.next = node
	
	# 表尾添加
	def append(self, 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
	        node.next = cur.next
	        cur.next = node
	
	# 指定位置添加
	def insert(self, pos, item):
	    node = Node(item)
	    if pos <= 0:
	        self.add(item)  # 头部添加
	    elif pos > (self.length() - 1):
	        self.append(item)  # 尾部添加
	    else:
	        pre = self.__head
	        count = 0
	        while count < (pos - 1):
	            count += 1
	            pre = pre.next
	        # 当循环退出后，pre指向pos-1位置
	        node.next = pre.next
	        pre.next = node
	
	# 删除指定节点
	def remove(self, item):
	    if self.is_empty():
	        return
	    cur = self.__head
	    pre = 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:
	                pre.next = cur.next
	            return
	        else:
	            pre = cur
	            cur = cur.next
	    # 退出循环，cur指向尾节点
	    if cur.elem == item:
	        # 链表只有一个节点的尾节点
	        if cur == self.__head:
	            self.__head = None
	        #删除多个节点的尾部节点
	        else:
	            pre.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
	    # 退出循环，cur指向尾节点
	    if cur.elem == item:
	        return True
	    return False

测试

if __name__ == '__main__':
    ll = SingleCycleLinkList()
    print(ll.is_empty())
    print(ll.length())
    ll.append(1)
    ll.add(8)
    print(ll.is_empty())
    print(ll.length())
    ll.append(2)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.insert(7, 9)
    # ll.travel()
    ll.remove(1)
    ll.travel()

结果如图