数据结构与算法 python--第三节 链表之单向循环链表

3 链表

3.1 单向链表

见前博客：数据结构与算法 python–第三节 链表之单向链表

3.2 双向链表

见前博客：数据结构与算法 python–第三节 链表之双向链表

3.3 单向循环链表

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

操作：

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

注意: 不管何种操作，在核心代码满足一般情况之后，一定要再考虑是否满足以下情形：

• 链表为空
• 链表仅有一个节点
• 尾节点一定要指向首节点

遍历元素travel()

def travel(self):
        """遍历整个链表"""
        if self.is_empty():
            return
        cur = self.__head
        while cur.next != self.__head:
            print(cur.elem, end=" ")
            cur = cur.next
        # 退出循环，cur指向尾节点，但尾节点的元素未打印
        print(cur.elem)

链表长度length()

def length(self):
    """链表长度"""
    if self.is_empty():
        return 0
    # cur游标，用来移动遍历节点
    cur = self.__head
    # count记录数量
    count = 1
    while cur.next != self.__head:
        count += 1
        cur = cur.next
    return count

头部添加元素add()

需要进行的操作有：
a、新元素.next指向原头结点；b、self._head指向新元素；c、游标在链表中后移，直到指向尾节点；d、进行链表尾节点.next指向新元素
方式一：

操作顺序是：a b c d
核心代码是：

node = Node(item)
node.next = self._head
self = node
cur.next = node.next:# 条件
    cur.next = node

此方法的循环条件和以往有区别，采用更多的是第二种

方式二：
操作顺序是：c a b d

完整代码是：

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  #此行代码与下行代码作用相同
        cur.next = self.__head

尾部添加元素append()

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  #此行代码与下行代码作用相同
        node.next = self.__head
        cur.next = node  

指定位置添加元素insert()

除了在单向循环链表的头部添加和尾部添加操作外，在指定位置添加元素并不涉及尾节点.next的改变，所以在中间某指定位置添加元素和单向链表操作完全一样，代码无需更改

def insert(self, pos, item):
        """指定位置添加元素
        :param  pos 从0开始
        """
        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 = Node(item)
            node.next = pre.next
            pre.next = node 

查找元素search()

def search(self,item):
    """查找节点是否存在"""
    if 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

删除元素remove()

删除元素要清楚一下几点：

• 若要删除的元素在链表中间，那么和单链表操作一样，不用考虑首尾节点
• 若删除的是头结点，因单向循环链表的尾节点要指向头结点，所以删除头结点时也要游标遍历到尾节点处，改变尾节点的指向；此时需要有两层循环，外层循环寻找相应值的节点，内层循环是因为删除头结点时需要找到尾节点
• 若删除尾节点，则要让前一个节点指向self._head

    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
                pre.next = self.__head

注意：下图中圈出的return很重要，如若没有这个return，那么当要删除的元素为头结点时，在执行了if cur == self._head: # 头结点这个 if 循环后，已经将头结点删除掉，其中pre并没有改变，依旧是pre = None；因为缺少了return，所以代码会继续进入while循环外面的if cur.elem == item:因为pre=None，所以没有next，pre.next报错！！

另：
return：跳出函数
break：跳出循环
continue：继续循环，(不执行 循环体内continue 后面的语句，直接进行下一循环）

整体代码

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
        while cur.next != self.__head:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历整个链表"""
        if self.is_empty():
            return
        cur = self.__head
        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
            cur.next = self.__head

    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
            node.next = self.__head
            cur.next = node

    def insert(self, pos, item):
        """指定位置添加元素
        :param  pos 从0开始
        """
        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 = Node(item)
            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
                pre.next = self.__head

    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)
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    # 8 1 2 3 4 5 6
    ll.insert(-1, 9) # 9 8 1 23456
    ll.travel()
    ll.insert(3, 100) # 9 8 1 100 2 3456
    ll.travel()
    ll.insert(10, 200) # 9 8 1 100 23456 200
    ll.travel()
    ll.remove(100)
    ll.travel()
    ll.remove(9)
    ll.travel()
    ll.remove(200)
    ll.travel()

结果