数据结构与算法笔记1之 稀疏数组与数组模拟队列

稀疏数组

概念：很多时候二维数组存储数据有很多地方为0，占地方又实际意义，优化数组就用到稀疏数组，它记录原始数组有几行几列、有几个有效数据、以及每个值的分布索引，以此缩小储存空间达到优化的目的。

如图：
（模拟11×11棋盘二维数组与稀疏数组的转换）
代码展示：

//创建原始二维数组11*11
        //0代表无棋子，1代表黑子，2代表蓝子
        int chessArr1[][] =new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;
        chessArr1[4][5]=2;
        //输出原始的二维数组
        System.out.println("原始二维数组：");
        for (int[] row:chessArr1) {
            for (int data:row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        //将二维数组转为稀疏数组
         //先遍历数组得到有几个非0的数据
        int sum = 0;
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if (chessArr1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println();
        System.out.println("sum="+sum);
        //遍历完数组就创建对应的稀疏数组
         int[][] sparseArray=new int[sum+1][3];
         //给稀疏数组赋值
        sparseArray[0][0]=11;
        sparseArray[0][1]=11;
        sparseArray[0][2]=sum;

        int count = 1;//计数器
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if (chessArr1[i][j]!=0){
                    sparseArray[count][0]=i;
                    sparseArray[count][1]=j;
                    sparseArray[count][2]=chessArr1[i][j];
                    count++;
                }
            }
        }
        //输出稀疏数组
        System.out.println();
        System.out.println("稀疏数组：");
        for (int i=0;i<sparseArray.length;i++){
            System.out.printf("%d\t%d\t%d\t\n",sparseArray[i][0],sparseArray[i][1],sparseArray[i][2]);
        }
        System.out.println();
        //将稀疏数组恢复成二维数组
        int chessArr2 [][]=new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i =1;i<sparseArray.length;i++){
                chessArr2[sparseArray[i][0]][sparseArray[i][1]]=sparseArray[i][2];
        }
        for (int[] row:chessArr2) {
            for (int data:row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

用数组实现队列

概念：队列本身是有序列表，可以用数组或者链表来实现，遵循先进先出原则，先入队列的数据要先取出。当尾指针=队列maxsize-1时，队列满，无法再插入新数据。

public class ArrayQueueDemo {
    public static void main(String[] args) {
        //创建一个队列
        ArrayQueue queue = new ArrayQueue(3);
        Scanner scanner =new Scanner(System.in);
        boolean a=true;
        while (a){
            System.out.println("show:显示队列");
            System.out.println("exit:退出程序");
            System.out.println("add:添加数据到队列");
            System.out.println("get:从队列取出数据");
            String sysIn =scanner.next();
            switch (sysIn){
                case "show":
                    queue.showQueue();
                    break;
                case "add":
                    System.out.println("请输入要添加的数");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case "get":
                    try {
                        int result=queue.getQueue();
                        System.out.println("取出的数据为："+result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    a=false;
                    break;
                default:
                     break;
            }
        }
    }
}
//使用数组模拟队列-写一个ArrayQueue类
class ArrayQueue {
    private int maxSize;//数组最大容量
    private int front; //队列头
    private int rear;//队列尾
    private int[] arr;//用数组模拟队列存放数据

    public ArrayQueue(int arrMaxSize){
        maxSize=arrMaxSize;
        front=-1;//指向队列头部（头部数据前一个位置）
        rear=-1;//指向队列尾部的数据；
        arr=new int[maxSize];
    }
    //判断当前队列是否满
    public boolean isFull(){
        return rear==maxSize-1?true:false;
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return rear==front?true:false;
    }
    //队列添加数据
    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.println(arr[i]);
        }
    }
}

未用到环形队列，有待改进。。。（接下文）