python语言单向循环链表

单向循环链表

单向循环链表和单向链表的区别在于：尾结点不指向None，而是指向头结点。

---

单向循环链表所报含的操作和单向链表一致：

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

---

相对于单向链表的区别：

• 1.遍历条件不同，单链表尾结点指向None，循环链表尾结点指向头结点。
• 2.涉及到头部、尾部的插入、删除节点操作不同。
• 3.删除节点时需考虑多种情况：是否为头结点、是否为尾结点、是否只包含一个节点。

这里会详细解析不同于单链表的操作，并在末尾附上全代码。

---

添加节点

头部添加节点

首先要考虑是否为空链表，若是则直接添加作为头结点，若不是：

• 1.将新节点指向原先的头部节点
• 2.将新节点替换为新头结点
• 3.将尾结点指向新头结点
  
  具体代码如下：

 def add(self, item):
        """头部添加元素，需要寻找尾结点，指向新插入的头结点"""
        # 创建节点，Node为自定义的节点类
        node = Node(item)
        # 特殊情况，空链表
        if self.is_empty():
            self._head = node
            node.next = node
        else:
            # 寻找尾结点
            cur = self._head
            # 注意遍历条件，循环推出时，cur指向尾结点
            while cur.next != self._head:
                cur = cur.next
            # 让新节点指向头结点，保证后面节点不丢失
            node.next = self._head
            #再更换头结点
            self._head = node
            # 尾结点指向新头结点，构成循环
            cur.next = node

---

尾部添加节点

同样先判断是否为空链表，若是则直接添加作为头结点，若不是：

• 1.新节点指向原有头结点
• 2.原尾结点指向新节点
  
  具体代码如下：

    def append(self, item):
        """尾部添加元素"""
        # 创建节点，Node为自定义的节点类
        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

---

删除节点

删除节点操作比较复杂，需要考虑一下四种情况：

• 1.删除的节点为头结点
• 2.删除的节点为尾结点
• 3.链表只包含一个节点
• 4.删除中间节点

关于前驱节点和后驱节点，比如A->B->C，那么A是B的前驱节点，C是B的后驱节点

删除时，需要两个游标，一个游标指示当前要删除的节点，一个游标指向要删除节点的前驱节点，对于A->B->C要删除B的话，语句如下：

#A的后驱节点指向B的后驱节点
A.next = B.next 

此时A->C，虽然B仍然指向C但对循环链表无影响。

结合上述删除语句和四种情况，具体代码如下：

    def remove(self, item):
        """删除节点"""
        # 空链表情况
        if self.is_empty():
            return
        #前驱游标
        pre = None
        #指向删除节点的游标
        cur = self._head
        #遍历链表
        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

关于循环链表遍历需要注意的一点是：当遍历结束后游标指向尾结点，但尾结点未被循环体内的代码处理，所以要单独考虑。

比如遍历链表时，需单独打印尾结点。

ALL IN

全部代码如下：

# coding="utf-8"

class Node(object):
    """节点类"""
    def __init__(self, elem):
        # 存放元素
        self.elem = elem
        # 存放节点
        self.next = None


class SingleCircleLinkList(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):
        """返回链表长度"""
        # 特殊情况，空链表长度为0
        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 trval(self):
        """遍历列表"""
        # cur用来移动遍历数组
        cur = self._head
        # 特殊情况，空链表
        if self.is_empty():
            return
        while cur.next != self._head:
            print(cur.elem, end=" ")
            cur = cur.next
        # 退出循环时，指向尾结点，但尾结点未打印
        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
            # 让新节点指向头结点后部分的链表，保证后面不丢失
            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):
        """指定位置添加，不涉及到尾部，和单链表相同"""
        if pos <= 0:
            self.add(item)
        elif pos > self.length()-1:
            self.append(item)
        else:
            node = Node(item)
            pre = self._head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node

    def remove(self, item):
        """删除节点"""
        # 空链表情况
        if self.is_empty():
            return
        pre = None
        cur = self._head
        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
        if cur.elem == item:
            return  True
        return False

if __name__ =="__main__":
    ll = SingleCircleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    ll.append(2)
    ll.append(3)
    ll.trval()
    ll.insert(2, 5)
    ll.trval()
    ll.remove(1)
    ll.trval()

#测试结果
True
0
1 2 3
1 2 5 3
2 5 3

---

如有疑问或发现错误，欢迎交流！