数据结构预算法-稀疏数组与队列

一、稀疏数组

压缩条件：

    原数组中存在大量的无效数据，占据了大量的存储空间，真正有用的数据很少

    压缩存储可以节省储存空间，避免资源的不必要的浪费，在数据序列化到磁盘时，压缩存储可以提高IO效率。

稀疏数组处理方法：

    记录数组一共有几行几列，有多少个不同的值

   把具有不同值元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。

使用稀疏数组来保留如上二维数组 

把稀疏数组存盘可以重新恢复原来的二维数组

package com.mei.array;
//稀疏数组，压缩数据至稀疏数组
public class SparesArray   {
    public static void main(String[] args) {
        /*模拟出棋盘数据，使用二维数组*/
        int[][] array =new int[11][11];
        array[1][2]=1;
        array[2][4]=2;
        //打印棋盘查看结果
        for (int[] row :array){
            for (int val :row){
                System.out.printf("%d\t",val);
            }
            System.out.println();
        }
        /*需要把二维数组中的有效数据压缩至稀疏数组中*/
        //计算二维数组中有效数据
        int sum=0;
        for (int i = 0; i <11 ; i++) {
            for (int j = 0; j <11 ; j++) {
                if(array[i][j]!=0){
                    sum++;
                }
            }
        }
        //定义稀疏数组
        int[][]sparseArray=new int[sum+1][3];
        sparseArray[0][0]=11;
        sparseArray[0][1]=11;
        sparseArray[0][2]=sum;
        //把有效数据存放在稀疏数组中
        int count=0;
        for (int i = 0; i <11 ; i++) {//行的索引
            for (int j = 0; j <11 ; j++) {//列的索引
            if (array[i][j]!=0){
                count++;
                sparseArray[count][0]=i;
                sparseArray[count][1]=j;
                sparseArray[count][2]=array[i][j];
            }
            }
        }
        for (int i = 0; i <sparseArray.length ; i++) {
            System.out.printf("%d,%d,%d\t",sparseArray[i][0],sparseArray[i][1],sparseArray[i][2]);
        }
        /*把稀疏数组转原始二维数组*/
        int[][] oldArray =new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i <=count ; i++) {
            oldArray[sparseArray[i][0]][sparseArray[i][1]]=sparseArray[i][2];
        }
        System.out.println("---------------------------------------------");
        /*原始二维数组棋盘*/
        for (int[] row:oldArray){
            for (int val:row){
                System.out.printf("%d\t",val);
            }
            System.out.println();
        }

    }
}

二、队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头

1、 队列是一个有序列表，可以用数 组和链表来实现

2、 队列先进先出，即是先入队列的数据最先被取出，后存入的数据后取出。

数组模拟队列的入队出队以及查看队列元素

package com.mei.queue;

//队列基于数组实现

public class ArrayQueue {
    private int[] array;
    private int maxSize;
    private int frontPoint;
    private int rearPoint;

    public ArrayQueue(int maxSize){
        this.maxSize=maxSize;
        array = new int[maxSize];
        frontPoint=-1;
        rearPoint=-1;
    }
    /*判断当前队列是否已满*/
    public boolean isFull(){
        return rearPoint==maxSize-1;
    }
    /*判断是否为空队列*/
    public boolean isEmpty(){
        return frontPoint==rearPoint;
    }
    /*添加元素进入队列*/
    public void add(int n ){
        if (isFull()){
            System.out.println("队列已满");
            return;
        }
        rearPoint++;
        array[rearPoint]=n;
    }
    /*获取队列元素并且删除元素，出队列*/
    public int get(){
        if (isEmpty()){
            throw new RuntimeException("空队列");
        }
        frontPoint++;//指针右移
        return array[frontPoint];
    }
    public void findQueue(){
        if (isEmpty()){
            throw new RuntimeException("空队列");
        }
        for (int i = 0; i < array.length; i++) {
            System.out.printf("array[%d]=%d\n",i,array[i]);
        }
    }
    /*查看队头元素 */
    public int frontQueue() {
        if (isEmpty()) {
            throw new RuntimeException("空队列");
        }
        return array[frontPoint];
    }
}