稀疏数组与队列

1.稀疏数组（sparsearray）

1.1 背景

1.2 介绍

当一个数组大部分元素为0和某个值时可以用稀疏数组来保存。

1.3 代码实现

public class sparsearray {

    public static void main(String[] args) {
        int[][] arrs=new int[10][10];
        arrs[1][2]=1;
        arrs[2][3]=2;
        arrs[4][5]=2;

        //输出原始二维数组
        System.out.println("原始数组--------");

        for (int[] a:arrs){
            System.out.println(Arrays.toString(a));
        }

        //转换为稀疏数组
        //1.先确定数组非0的个数
        int sum=0;
        for (int i=0;i<arrs.length;i++){
            for (int j=0;j<arrs[i].length;j++){
                if (arrs[i][j]!=0){
                    sum++;
                }
            }
        }

        //2.创建稀疏数组
        int[][] sparsearrs=new int[sum+1][3];
        sparsearrs[0][0]=arrs.length;
        sparsearrs[0][1]=arrs[0].length;

        int cout=1;
        for (int i=0;i<arrs.length;i++){
            for (int j=0;j<arrs[i].length;j++){
                if (arrs[i][j]!=0){
                    sparsearrs[cout][0]=i;
                    sparsearrs[cout][1]=j;
                    sparsearrs[cout][2]=arrs[i][j];
                    cout++;
                }
            }
        }


        //输出稀疏数组
        System.out.println("稀疏数组------");
        for (int[] a:sparsearrs){
            System.out.println(Arrays.toString(a));
        }

        //恢复为普通数组
        int[][] arrss=new int[sparsearrs[0][0]][sparsearrs[0][1]];
        for (int i=1;i<sparsearrs.length;i++){
            arrss[sparsearrs[i][0]][sparsearrs[i][1]]=sparsearrs[i][2];
        }

        //输出普通数组
        System.out.println("输出恢复数组-------");
        for (int[] a:arrss){
            System.out.println(Arrays.toString(a));
        }
    }
}

2.队列

2.1 背景

2.2 介绍

1. 队列是个有序列表，可以用数组和链表实现。
2. 遵循先进先出原则。
3. 示意图：

2.3 代码实现

class MyQueue{
    private int maxSize;//最大容量
    private int front;//队头
    private int rear;//队尾
    private int[] arr;// 队列数据

    public MyQueue(int maxSize){
        this.maxSize=maxSize;
        arr=new int[maxSize];
    }

    //判断队列是否为满
    public boolean isFull(){
        return (rear+1)%maxSize==front;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return rear==front;
    }

    //添加数据
    public void addQueue(int n){
        if (isFull()){
            System.out.println("队列已满");
            return ;
        }
        arr[rear]=n;
        rear=(rear+1)%maxSize;

    }

    //获取头数据
    public int getQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空");
        }
        int a=arr[front];
        front=(front+1)%maxSize;
        return a;
    }

    //显示所有数据
    public void showQueue(){
        if (isEmpty()){
            System.out.println("队列为空");
            return;
        }
        for (int i=front;i<front+size();i++){
            System.out.print(arr[i%maxSize]+" ");
        }
    }

    //返回有效队列数据的个数
    public int size(){
        return (rear+maxSize-front)%maxSize;
    }

    //显示队头（不取出）
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空");
        }
        return arr[front];
    }
}