队列的链式存储结构及其基本运算的实现

队列是一种先进先出（First In First Out, FIFO）的线性数据结构，它只允许在一端（队尾）进行插入操作，在另一端（队头）进行删除操作。队列的链式存储结构通常是通过链表来实现的。在链式存储结构中，队列由一个带有头结点的单链表表示，链表的一端作为队头，另一端作为队尾。

链式队列的结构

在链式队列中，通常包含以下几个基本元素：

• 结点（Node）: 每个结点包含两个部分，一个是存储数据的data字段，另一个是指向下一个结点的指针next。
• 头指针（front）: 指向队列的第一个元素。
• 尾指针（rear）: 指向队列的最后一个元素。

基本运算的实现

链式队列的基本运算主要包括以下几种：

1. 初始化（initQueue）: 初始化一个空队列。
2. 入队（enqueue）: 在队列的尾部添加一个元素。
3. 出队（dequeue）: 删除队列头部的元素并返回其值。
4. 判断队空（isEmpty）: 检查队列是否为空。

以下是用Python实现链式队列的一个简单例子：

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

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

    def is_empty(self):
        return self.front is None

    def enqueue(self, value):
        new_node = Node(value)
        if self.rear is None:
            self.front = self.rear = new_node
            return
        self.rear.next = new_node
        self.rear = new_node

    def dequeue(self):
        if self.is_empty():
            raise Exception("Trying to dequeue from an empty queue")
        temp = self.front
        self.front = self.front.next
        if self.front is None:
            self.rear = None
        return temp.data

    def peek(self):
        if self.is_empty():
            raise Exception("Queue is empty")
        return self.front.data

使用示例

q = LinkedQueue()
q.enqueue(10)
q.enqueue(20)
q.enqueue(30)
print(q.dequeue())  # 输出: 10
print(q.peek())     # 输出: 20
q.enqueue(40)
print(q.dequeue())  # 输出: 20

总结

这个例子展示了如何使用Python定义一个简单的链式队列，并实现了入队、出队、判断队空和查看队首元素的操作。这种结构非常适合实现动态数据集合的队列操作，因为它不需要预先知道数据容量的大小，且每个操作（除了非空检查外）的时间复杂度为O(1)。

Java 实现

在Java中实现链式队列也遵循相似的逻辑。我们将定义一个Node类用来表示队列中的每个节点，以及一个LinkedQueue类来实现队列的基本操作。以下是Java版本的实现：

Node 类

public class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

LinkedQueue 类

public class LinkedQueue {
    private Node front, rear;

    public LinkedQueue() {
        this.front = this.rear = null;
    }

    public boolean isEmpty() {
        return front == null;
    }

    public void enqueue(int data) {
        Node newNode = new Node(data);
        if (this.rear == null) {
            this.front = this.rear = newNode;
            return;
        }
        this.rear.next = newNode;
        this.rear = newNode;
    }

    public int dequeue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        int data = front.data;
        front = front.next;
        if (front == null) {
            rear = null;
        }
        return data;
    }

    public int peek() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        return front.data;
    }
}

使用示例

在一个主类中，我们可以创建队列对象并使用它进行基本的队列操作：

public class Main {
    public static void main(String[] args) {
        LinkedQueue queue = new LinkedQueue();
        queue.enqueue(10);
        queue.enqueue(20);
        queue.enqueue(30);
        
        System.out.println(queue.dequeue()); // 输出: 10
        System.out.println(queue.peek());    // 输出: 20
        queue.enqueue(40);
        System.out.println(queue.dequeue()); // 输出: 20
    }
}

总结

这段代码成功地在Java中实现了一个链式队列。我们定义了Node类来存储数据和指向下一个节点的引用，并在LinkedQueue类中实现了enqueue、dequeue、peek和isEmpty方法来进行队列的基本操作。每个操作（除了检查队列是否为空外）的时间复杂度都是O(1)，这使得链式队列成为处理动态数据集合的有效结构。