java如何声明队列和栈

Java如何声明队列和栈

引言

在日常开发中，我们经常需要使用队列和栈这两种数据结构来解决实际问题。队列和栈是非常常见和重要的数据结构，对于开发者来说，掌握它们的使用方法是十分必要的。本文将介绍如何在Java中声明队列和栈，并通过一个实际问题来演示它们的使用。

队列

队列是一种先进先出（FIFO）的数据结构，类似于我们日常生活中排队的场景。在Java中，可以使用java.util.Queue接口来声明队列。以下是一个示例：

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        // 入队
        queue.add("A");
        queue.add("B");
        queue.add("C");

        // 出队
        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
    }
}

上述代码中，我们使用LinkedList实现了一个队列，并添加了元素"A"、"B"和"C"。然后，通过循环遍历队列，每次取出一个元素并打印出来。输出结果为：

A
B
C

栈

栈是一种后进先出（LIFO）的数据结构，类似于我们日常生活中摞放书本的场景。在Java中，可以使用java.util.Stack类来声明栈。以下是一个示例：

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();

        // 压栈
        stack.push("A");
        stack.push("B");
        stack.push("C");

        // 出栈
        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
    }
}

上述代码中，我们使用Stack类实现了一个栈，并压入了元素"A"、"B"和"C"。然后，通过循环遍历栈，每次弹出栈顶元素并打印出来。输出结果为：

C
B
A

实际问题：使用队列解决广度优先搜索问题

队列在广度优先搜索（BFS）中经常被使用。广度优先搜索是一种图搜索算法，用于在图中找出两个节点之间的最短路径。下面是一个使用队列解决广度优先搜索问题的示例：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class BFSExample {
    public static void main(String[] args) {
        int[][] graph = {
                {0, 1, 1, 0, 0},
                {1, 0, 0, 1, 1},
                {1, 0, 0, 0, 0},
                {0, 1, 0, 0, 0},
                {0, 1, 0, 0, 0}
        };

        List<Integer> shortestPath = bfs(graph, 0, 4);
        System.out.println("Shortest path: " + shortestPath);
    }

    private static List<Integer> bfs(int[][] graph, int start, int end) {
        int n = graph.length;
        boolean[] visited = new boolean[n];
        int[] parent = new int[n];
        Queue<Integer> queue = new LinkedList<>();

        visited[start] = true;
        queue.add(start);

        while (!queue.isEmpty()) {
            int current = queue.poll();

            if (current == end) {
                return buildPath(parent, start, end);
            }

            for (int i = 0; i < n; i++) {
                if (graph[current][i] == 1 && !visited[i]) {
                    visited[i] = true;
                    parent[i] = current;
                    queue.add(i);
                }
            }
        }

        return new ArrayList<>();
    }

    private static List<Integer> buildPath(int[] parent, int start, int end) {
        List<Integer> path = new ArrayList<>();
        int current = end;

        while (current != start) {
            path.add(0, current);
            current = parent[current];
        }

        path.add(0, start);
        return path;
    }
}

上述代码中，我们使用队列来实现广度优先搜索算法。给定一个图的邻接矩阵表示`graph