思维导图：

代码1（完成双向循环链表的判空、尾插、遍历、尾删）：

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None

class DoubleCycleLink:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    #判空
    def is_empty(self):
        return self.size == 0

    #尾插
    def add_tail(self, data):
        node = Node(data)
        if self.is_empty():
            self.head = node
            self.tail = node
            node.next = self.head
            node.prev = self.tail
            self.size += 1
        else:
            node.prev = self.tail
            node.next = self.head
            self.tail.next = node
            self.tail = node
            self.head.prev = self.tail
            self.size += 1

    #遍历
    def show(self):
        if self.is_empty():
            print("空链表")
        else:
            q = self.head
            while q != self.tail:
                print(q.data, end=" ")
                q = q.next
            print(q.data)

    #尾删
    def delete_tail(self):
        if self.is_empty():
            print("空链表")
        else:
            self.tail = self.tail.prev
            self.tail.next = self.head
            self.head.prev = self.tail
            self.size -= 1

if __name__ == "__main__":
    link = DoubleCycleLink()
    link.add_tail(10)
    link.add_tail(20)
    link.add_tail(30)
    link.add_tail(40)
    link.add_tail(50)
    link.show()
    print("=============================")
    link.delete_tail()
    link.show()

代码2（不使用内置函数的情况下，完成顺序栈的创建栈、判空、入栈、出栈、获取栈顶元素、求栈的大小、遍历栈）：
 

# 不使用内置函数实现顺序栈
class Stack:
    def __init__(self, capacity=10):
        self.capacity = capacity
        self.top = -1
        self.data = [None] * capacity
        self.size = 0

    # 入栈
    def push(self, data):
        if self.top == self.capacity - 1:
            print("栈已满")
            return
        self.top += 1
        self.data[self.top] = data
        self.size += 1

    # 遍历
    def show(self):
        for i in range(self.top, -1, -1):
            print(self.data[i], end=" ")
        print()

    # 出栈
    def pop(self):
        if self.top == -1:
            print("栈已空")
            return
        self.top -= 1
        self.size -= 1

    # 获取栈顶元素
    def top(self):
        if self.top == -1:
            print("栈已空")
            return
        return self.data[self.top]

    # 获取栈大小
    def size(self):
        return self.size


if __name__ == '__main__':
    stack = Stack()
    for i in range(10):
        stack.push(i)

    stack.show()
    stack.pop()
    stack.show()
    print(stack.top)
    print(stack.size)

代码3（不使用内置函数的情况下，完成链式栈的创建栈、判空、入栈、出栈、获取栈顶元素、求栈的大小、遍历栈）：

#不使用内置函数实现链式栈
# 普通节点
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None


# 带头节点的单向链表
class LinkList:
    def __init__(self, node=None):
        self.size = 0  # 链表长度
        self.head = node  # 头结点

    # 判空
    def is_empty(self):
        # return self.head is None
        return self.size == 0

    # 头插
    def add_head(self, data):
        node = Node(data)
        if self.is_empty():
            self.head = node
            self.size += 1
        else:
            node.next = self.head
            self.head = node
            self.size += 1

    # 遍历
    def show(self):
        if self.is_empty():
            print("空链表")
        else:
            p = self.head
            while p:
                print(p.data, end=" ")
                p = p.next
            print()

    # 头删
    def delete_head(self):
        if self.is_empty():
            print("空链表")
        else:
            self.head = self.head.next
            self.size -= 1

    #获取栈顶元素
    def top(self):
        if self.is_empty():
            print("空链表")
        else:
            return self.head.data

    #获取栈的长度
    def size(self):
        return self.size






if __name__ == '__main__':
    # 构造一个单向链表
    link = LinkList()
    link.add_head(1)
    link.add_head(3)
    link.add_head(5)
    link.add_head(4)
    link.add_head(7)
    link.add_head(9)
    link.show()
    print("=============================")
    link.delete_head()  # 头删
    link.show()
    print("=============================")
    num = link.top()  # 获取栈顶元素
    print(f"栈顶元素为{num}")
    print("=============================")
    length = link.size  # 获取栈的长度
    print(f"栈的长度为{length}")