链式队列栈表，用代码实现增删改查

链式队列、栈和表通常是在数据结构课程中讨论的基本概念。它们都是线性数据结构，但在操作上略有不同：

1. **队列**（Queue）是一种先进先出（FIFO，First In First Out）的数据结构，类似于现实生活中的排队。常见的链式队列实现通常是通过两个指针，一个指向当前元素（头），另一个指向下一个将要入队的位置（尾）。以下是Python中链式队列的简单实现：

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

class LinkedListQueue:
    def __init__(self):
        self.front = None
        self.rear = None

    # 添加元素到队尾
    def enqueue(self, data):
        new_node = Node(data)
        if not self.rear:
            self.front = self.rear = new_node
        else:
            self.rear.next = new_node
            self.rear = new_node

    # 删除并返回队首元素
    def dequeue(self):
        if not self.front:
            return None
        temp_data = self.front.data
        self.front = self.front.next
        if not self.front:
            self.rear = None
        return temp_data

2. **栈**（Stack）是一种后进先出（LIFO，Last In First Out）的数据结构，像一层层书叠起来一样。链式栈一般只有一个指针，表示栈顶。Python的列表可以轻松模拟栈：

class Stack:
    def __init__(self):
        self.stack = []

    # 入栈
    def push(self, item):
        self.stack.append(item)

    # 出栈
    def pop(self):
        if not self.is_empty():
            return self.stack.pop()
        else:
            return None

    # 判断是否为空
    def is_empty(self):
        return len(self.stack) == 0

3. **表**（Table 或者也叫矩阵）是一维或多维的数据结构，用于存储元素对，每个位置对应一对值。在链表中实现二维数组可能不太常见，但如果要用动态内存分配，可以类似下面这样创建节点，然后关联起来：

class TableNode:
    def __init__(self, row, col, value=None):
        self.row = row
        self.col = col
        self.value = value
        self.next = None

class LinkedTable:
    def __init__(self, rows, cols):
        self.rows = rows
        self.cols = cols
        self.head = None

    # 二维插入和读取
    def insert(self, row, col, value):
        if (row < 0 or row >= self.rows) or (col < 0 or col >= self.cols):
            raise IndexError("Invalid coordinates")
        node = TableNode(row, col, value)
        if not self.head:
            self.head = node
        else:
            cur_node = self.head
            while cur_node.next:
                cur_node = cur_node.next
            cur_node.next = node

    def get(self, row, col):
        if (row < 0 or row >= self.rows) or (col < 0 or col >= self.cols):
            return None
        cur_node = self.head
        for _ in range(row):
            cur_node = cur_node.next
        return cur_node.value if cur_node else None

**