java中如何实现队列和栈

在Java中，实现队列和栈的方法主要有：使用内置的类、使用链表、使用数组。 其中，使用Java内置的类最为简单和直观，而使用链表和数组则可以提供更高的灵活性和定制性。本文将详细介绍这三种方法的具体实现，并为每种方法提供代码示例和实际应用场景的分析。

一、使用Java内置的类

1、队列的实现

在Java中，Queue接口和Deque接口提供了内置的队列实现。LinkedList类和ArrayDeque类是最常用的实现类。

LinkedList实现队列

import java.util.LinkedList;
import java.util.Queue;
public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        // 添加元素
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        // 访问头元素
        System.out.println("Head of queue: " + queue.peek());
        // 移除元素
        System.out.println("Removed from queue: " + queue.poll());
        System.out.println("Removed from queue: " + queue.poll());
        // 查看队列元素
        System.out.println("Queue elements: " + queue);
    }
}

ArrayDeque实现队列

import java.util.ArrayDeque;
import java.util.Queue;
public class ArrayDequeExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new ArrayDeque<>();
        // 添加元素
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        // 访问头元素
        System.out.println("Head of queue: " + queue.peek());
        // 移除元素
        System.out.println("Removed from queue: " + queue.poll());
        System.out.println("Removed from queue: " + queue.poll());
        // 查看队列元素
        System.out.println("Queue elements: " + queue);
    }
}

2、栈的实现

在Java中，Stack类是实现栈的最常用类，但也可以使用Deque接口的实现类如ArrayDeque来实现栈。

Stack类实现栈

import java.util.Stack;
public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        // 添加元素
        stack.push(1);
        stack.push(2);
        stack.push(3);
        // 访问顶部元素
        System.out.println("Top of stack: " + stack.peek());
        // 移除元素
        System.out.println("Removed from stack: " + stack.pop());
        System.out.println("Removed from stack: " + stack.pop());
        // 查看栈元素
        System.out.println("Stack elements: " + stack);
    }
}

ArrayDeque实现栈

import java.util.ArrayDeque;
import java.util.Deque;
public class ArrayDequeStackExample {
    public static void main(String[] args) {
        Deque<Integer> stack = new ArrayDeque<>();
        // 添加元素
        stack.push(1);
        stack.push(2);
        stack.push(3);
        // 访问顶部元素
        System.out.println("Top of stack: " + stack.peek());
        // 移除元素
        System.out.println("Removed from stack: " + stack.pop());
        System.out.println("Removed from stack: " + stack.pop());
        // 查看栈元素
        System.out.println("Stack elements: " + stack);
    }
}

二、使用链表

1、链表实现队列

使用链表实现队列的方法非常灵活，可以轻松处理动态大小的队列。

链表实现队列的代码示例

public class LinkedListQueue {
    private Node front, rear;
    private int size;
    private class Node {
        int data;
        Node next;
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }
    public LinkedListQueue() {
        front = rear = null;
        size = 0;
    }
    public void enqueue(int data) {
        Node newNode = new Node(data);
        if (rear == null) {
            front = rear = newNode;
        } else {
            rear.next = newNode;
            rear = newNode;
        }
        size++;
    }
    public int dequeue() {
        if (front == null) {
            throw new IllegalStateException("Queue is empty");
        }
        int data = front.data;
        front = front.next;
        if (front == null) {
            rear = null;
        }
        size--;
        return data;
    }
    public int peek() {
        if (front == null) {
            throw new IllegalStateException("Queue is empty");
        }
        return front.data;
    }
    public boolean isEmpty() {
        return front == null;
    }
    public int size() {
        return size;
    }
    public static void main(String[] args) {
        LinkedListQueue queue = new LinkedListQueue();
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        System.out.println("Head of queue: " + queue.peek());
        System.out.println("Removed from queue: " + queue.dequeue());
        System.out.println("Removed from queue: " + queue.dequeue());
        System.out.println("Queue elements: " + queue.size());
    }
}

2、链表实现栈

使用链表实现栈也非常灵活，栈的顶部和链表的头部可以自然地对应起来。

链表实现栈的代码示例

public class LinkedListStack {
    private Node top;
    private int size;
    private class Node {
        int data;
        Node next;
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }
    public LinkedListStack() {
        top = null;
        size = 0;
    }
    public void push(int data) {
        Node newNode = new Node(data);
        newNode.next = top;
        top = newNode;
        size++;
    }
    public int pop() {
        if (top == null) {
            throw new IllegalStateException("Stack is empty");
        }
        int data = top.data;
        top = top.next;
        size--;
        return data;
    }
    public int peek() {
        if (top == null) {
            throw new IllegalStateException("Stack is empty");
        }
        return top.data;
    }
    public boolean isEmpty() {
        return top == null;
    }
    public int size() {
        return size;
    }
    public static void main(String[] args) {
        LinkedListStack stack = new LinkedListStack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println("Top of stack: " + stack.peek());
        System.out.println("Removed from stack: " + stack.pop());
        System.out.println("Removed from stack: " + stack.pop());
        System.out.println("Stack elements: " + stack.size());
    }
}

三、使用数组

1、数组实现队列

使用数组实现队列需要处理数组的固定大小问题，通常使用循环队列来解决这一问题。

数组实现队列的代码示例

public class ArrayQueue {
    private int[] queue;
    private int front, rear, size, capacity;
    public ArrayQueue(int capacity) {
        this.capacity = capacity;
        queue = new int[capacity];
        front = size = 0;
        rear = capacity - 1;
    }
    public boolean isFull() {
        return size == capacity;
    }
    public boolean isEmpty() {
        return size == 0;
    }
    public void enqueue(int item) {
        if (isFull()) {
            throw new IllegalStateException("Queue is full");
        }
        rear = (rear + 1) % capacity;
        queue[rear] = item;
        size++;
    }
    public int dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        int item = queue[front];
        front = (front + 1) % capacity;
        size--;
        return item;
    }
    public int peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        return queue[front];
    }
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(5);
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        System.out.println("Head of queue: " + queue.peek());
        System.out.println("Removed from queue: " + queue.dequeue());
        System.out.println("Removed from queue: " + queue.dequeue());
        System.out.println("Queue elements: " + queue.size());
    }
}

2、数组实现栈

使用数组实现栈比较简单，只需一个数组和一个指针来跟踪栈顶元素的位置。

数组实现栈的代码示例

public class ArrayStack {
    private int[] stack;
    private int top;
    private int capacity;
    public ArrayStack(int capacity) {
        this.capacity = capacity;
        stack = new int[capacity];
        top = -1;
    }
    public boolean isFull() {
        return top == capacity - 1;
    }
    public boolean isEmpty() {
        return top == -1;
    }
    public void push(int item) {
        if (isFull()) {
            throw new IllegalStateException("Stack is full");
        }
        stack[++top] = item;
    }
    public int pop() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty");
        }
        return stack[top--];
    }
    public int peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty");
        }
        return stack[top];
    }
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack(5);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println("Top of stack: " + stack.peek());
        System.out.println("Removed from stack: " + stack.pop());
        System.out.println("Removed from stack: " + stack.pop());
        System.out.println("Stack elements: " + stack.size());
    }
}

总结

在Java中实现队列和栈的方法有很多，主要包括使用Java内置的类、使用链表和使用数组。每种方法都有其优缺点，选择合适的方法取决于具体的应用场景和需求。使用Java内置的类最为简单和直观，适合于大多数常见的应用场景；使用链表提供了更高的灵活性，适合于需要动态调整数据结构大小的场景；使用数组则可以提供更高的访问速度和存储效率，适合于对性能有较高要求的场景。

通过本文的详细介绍和代码示例，相信读者能够更好地理解和掌握在Java中实现队列和栈的方法，并在实际开发中灵活运用这些知识。