算法与数据结构（Java版）01——稀疏数组和队列详解及代码实现

稀疏数组

所谓稀疏数组就是当数组中大部分的内容值都未被使用（或都为零），在数组中仅有少部分的空间使用。因此造成内存空间的浪费，为了节省内存空间，并且不影响数组中原有的内容值，我们可以使用稀疏数组去代替原始数组。

稀疏数组的实现思路如下：

• 将原始数组中的非零元素及其行列索引存储在一个新的数组中，称为稀疏数组。
• 在稀疏数组的第一行中存储稀疏数组的行数、列数和非零元素的个数。
• 在稀疏数组的其余行中存储非零元素的行列索引和值。

稀疏数组的优点：

• 节省内存空间。
• 便于查找非零元素。

稀疏数组的缺点：

• 访问非零元素的效率较低。
• 不支持随机访问。

队列

队列是一种先进先出（FIFO）的数据结构。队列的实现思路如下：

• 使用数组或链表来存储队列中的元素。
• 队头指针指向队列中的第一个元素。
• 队尾指针指向队列中的最后一个元素。

队列的优点：

• 实现简单。
• 访问效率高。
• 支持随机访问。

队列的缺点：

• 当队列满时，无法再插入元素。
• 当队列空时，无法再删除元素。

Java代码实现

// 稀疏数组
public class SparseArray {
    private int[][] sparseArray;
    private int row;
    private int column;
    private int nonZeroElements;

    public SparseArray(int[][] originalArray) {
        // 计算稀疏数组的行数、列数和非零元素的个数
        row = originalArray.length;
        column = originalArray[0].length;
        nonZeroElements = 0;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                if (originalArray[i][j] != 0) {
                    nonZeroElements++;
                }
            }
        }

        // 创建稀疏数组
        sparseArray = new int[nonZeroElements + 1][3];
        sparseArray[0][0] = row;
        sparseArray[0][1] = column;
        sparseArray[0][2] = nonZeroElements;

        // 将非零元素及其行列索引存储在稀疏数组中
        int index = 1;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                if (originalArray[i][j] != 0) {
                    sparseArray[index][0] = i;
                    sparseArray[index][1] = j;
                    sparseArray[index][2] = originalArray[i][j];
                    index++;
                }
            }
        }
    }

    // 将稀疏数组转换为原始数组
    public int[][] toOriginalArray() {
        int[][] originalArray = new int[row][column];
        for (int i = 1; i <= nonZeroElements; i++) {
            originalArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return originalArray;
    }

    // 输出稀疏数组
    public void printSparseArray() {
        for (int i = 0; i <= nonZeroElements; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(sparseArray[i][j] + " ");
            }
            System.out.println();
        }
    }
}

// 队列
public class Queue {
    private int[] elements;
    private int head;
    private int tail;
    private int size;

    public Queue(int maxSize) {
        elements = new int[maxSize];
        head = 0;
        tail = 0;
        size = 0;
    }

    public void enqueue(int element) {
        if (isFull()) {
            throw new IllegalStateException("Queue is full");
        }
        elements[tail] = element;
        tail = (tail + 1) % elements.length;
        size++;
    }

    public int dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        int element = elements[head];
        head = (head + 1) % elements.length;
        size--;
        return element;
    }

    public int peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        return elements[head