设有一个带头结点的单循环链表，请设计算法从这个链表中删除值为x的结点。若链表中没有值为x的结点，则打印“没有找到该结点”。

算法思路：

1.先找到x结点的前驱结点p和后继结点q。

2.然后将p的指针域指向q，释放要删除的结点。

3.注意特殊情况：要删除的结点就是头结点，或链表为空。

算法步骤：

1.初始化p为头结点，q为第一个结点。

2.在循环中查找值为x的结点，如果找到，则跳出循环；否则，继续向后查找。

3.如果找到了值为x的结点，则将p的指针域指向q的下一个结点，释放q结点，并打印删除成功信息。

4.否则，打印“没有找到该结点”。

代码实现：

# 定义节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
# 定义单循环链表类
class LinkedList:
    def __init__(self):
        self.head = Node(None)
        self.head.next = self.head
 
    # 添加结点到链表尾部
    def add_node(self, data):
        new_node = Node(data)
        p = self.head
        while p.next != self.head:
            p = p.next
        p.next = new_node
        new_node.next = self.head
 
    # 打印链表
    def print_list(self):
        p = self.head.next
        while p != self.head:
            print(p.data, end=' ')
            p = p.next
        print()
 
    # 删除值为x的结点
    def delete_node(self, x):
        if self.head.next == self.head:
            print("链表为空")
            return
        p = self.head
        q = self.head.next
        while q != self.head:
            if q.data == x:
                p.next = q.next
                del q
                print("删除成功")
                return
            else:
                p = q
                q = q.next
        print("没有找到该结点")
 
# 测试
if __name__ == '__main__':
    linked_list = LinkedList()
    linked_list.add_node(1)
    linked_list.add_node(2)
    linked_list.add_node(3)
    linked_list.add_node(4)
    linked_list.add_node(5)
    print("删除前：")
    linked_list.print_list()
    linked_list.delete_node(3)
    print("删除后：")
    linked_list.print_list()

输出结果：

删除前：
1 2 3 4 5 
删除成功
删除后：
1 2 4 5