稀疏数组和队列

稀疏数组

实际需求

编写五子棋程序中，有存盘退出和续上盘的功能
分析问题：
因为二维数组的很多值是默认值0，因此记录了很多没有意义的数据，所有用到稀疏数组。

基本介绍

当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

处理方法是：
1）记录数组一共有几行几列，有多少个不同的值
2）把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

应用实例

1）使用稀疏数组，来保留二维数组（棋盘、地图）
2）把稀疏数组存盘，并且可以从新恢复原来的二维数组数
3）整体思路分析

4）代码实现

		//创建一个原始的二维数组11*11
        //0：表示没有棋子，1：黑子   2：蓝子
        int chessArr1[][] = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
//        chessArr1[3][5] = 2;
//        System.out.println(chessArr1.length);

        //输出原始的二维数组
//        System.out.println("原始二维数组：");
//        for (int[] row : chessArr1){
//            for (int data : row){
//                System.out.printf("%d\t",data);
//            }
//            System.out.println();
//        }


        //将二维数组 转 稀疏数组
        //1. 先遍历二维数组 得到非零数据的个数
        int sum = 0;
        for (int i = 0; i<chessArr1.length; i++){
            for (int j = 0; j<chessArr1[0].length; j++){
                if (chessArr1[i][j] != 0){
                    sum++;
                }
            }
        }

        //2.创建对应的稀疏数组
        int sparseArr[][] = new int[sum+1][3];
        sparseArr[0][0] = chessArr1.length;
        sparseArr[0][1] = chessArr1[0].length;
        sparseArr[0][2] = sum;

        int count = 0;
        for (int i = 0; i<chessArr1.length; i++){
            for (int j = 0; j<chessArr1[0].length; j++){
                if (chessArr1[i][j] != 0){
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组：");
         for (int i=0 ; i<sparseArr.length; i++){
             System.out.printf("%d\t%d\t%d\t",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
             System.out.println();
         }



         //将稀疏数组 恢复成 原始的二维数组
        //1.读取稀疏数组第一行，创建二维数组
        int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];

         //读取稀疏数组后几行，并赋给原始二维数组
        for (int i=1; i<sparseArr.length; i++){
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        System.out.println("还原二维数组：");
        for (int[] row : chessArr2){
            for (int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

队列

使用场景

银行排队的案例

队列介绍

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

数组模拟队列思路

代码实现

class ArrayQueue{
    private int maxSize;
    private int front;
    private int rear;
    private int[] arr;

    public ArrayQueue(int maxSize){
        this.maxSize = maxSize;
        arr = new int[this.maxSize];
        front = -1;//指向队列头部的前一个位置
        rear = -1;//指向队列尾的数据（就是队列的最后一个位置）
    }

    public boolean isFull(){
        return rear == maxSize-1;
    }

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

    public void addQueue(int n){
        if (isFull()){
            System.out.println("队列已满");
            return;
        }
        rear++;
        arr[rear] = n;
    }

    public int getQueue(){
        if (isEmpty()){
             throw new RuntimeException("队列空，不能取数据");
        }
        front++;
        return arr[front];
    }

    public void showQueue(){
        if (isEmpty()){
            System.out.println("队列空的");
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d] = %d\n",i,arr[i]);
        }
    }

    public int peekQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列空的");
        }
        return arr[front+1];
    }
}

问题分析并优化

1. 目前数组使用一次就不能用了，没有达到复用效果
2. 改进成一个环形数组

数组模拟环形队列

代码实现

class CircleArray{
    private int maxSize;
    private int front;
    private int rear;
    private int[] arr;

    public CircleArray(int maxSize){
        this.maxSize = maxSize;
        arr = new int[this.maxSize];
        front = 0;//指向队列头部的数据（就是队列的第一个位置）
        rear = 0;//指向队列尾的数据前一个位置
    }

    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

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

    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 value = arr[front];
        front  = (front +1) % maxSize;
        return value;
    }

    public void showQueue(){
        if (isEmpty()){
            System.out.println("队列空的");
            return;
        }
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d] = %d\n",i%maxSize ,arr[i%maxSize]);
        }
    }

    public int size(){
        return (rear + maxSize - front) % maxSize;
    }

    public int peekQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列空的");
        }
        return arr[front];
    }
}