Java数据结构——稀疏数组及队列

数据结构稀疏数组及队列

一、数据结构和算法的关系

1. 数据(data)结构(structure)是一门研究组织数据方式的学科，有了编程语言就有了数据结构，学好数据结构可以编写出更加有效率的代码。
2. 学好数据结构要多考虑如何将生活中遇到的问题用程序去实现解决。
3. 程序 = 数据结构 + 算法
4. 数据结构是算法的基础，想要学好算法首先要学好数据结构。

二、数据结构

1、线性结构

1. 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。
2. 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的(地址)。
3. 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
4. 线性结构常见的有：数组、队列、链表和栈。

2、非线性结构

• 包括：二维数组、多维数组、广义表、树结构、图结构

三、稀疏数组

1、基本介绍

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

2、稀疏数组的处理方法

1. 记录数组一共有几行几列，有多少个不同的值
2. 把其中有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

3、举例说明

• 可以达到压缩的效果

4、应用实例

4.1 二维数组转稀疏数组

1. 遍历原始的二维数组，得到有效数据个数sum
2. 根据sum创建稀疏数组sparseArr int [sum+1] [3]
3. 将二维数组的有效数据存入稀疏数组中

4.2 稀疏数组转二维数组

1. 读取稀疏数组的第一行，根据第一行数据创建原始的二维数组，例如chessArr=int [11] [11]
2. 读取稀疏数组后几行的数据，并赋给原始二维数组

4.3 代码示例

/**
 * @author DELL
 * @Date 2019/12/23 15:45
 **/
public class SparseArrTest {
    public static void main(String[] args) {
        //0.创建原始二维数组
        //赋值：1表示黑色棋子，2表示蓝色棋子
        int [][]chessArr=new int[11][11];
        chessArr[1][2]=1;
        chessArr[2][3]=2;
        chessArr[4][5]=2;
        System.out.println("原始二维数组");
        for (int i = 0; i <chessArr.length ; i++) {
            for (int j = 0; j <chessArr[i].length ; j++) {
                System.out.printf("%d  ",chessArr[i][j]);
            }
            System.out.println();
        }
        //1.遍历二维数组，得到非0数据的个数
        int sum=0;
        for (int i = 0; i <chessArr.length ; i++) {
            for (int j = 0; j <chessArr[i].length ; j++) {
                if(chessArr[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println(sum);
        //2.创建稀疏数组
        int [][]sparseArr=new int [sum+1][3];
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=sum;
        //3.遍历二维数组，对稀疏数组赋值
        //用于记录是第几个非0数据
        int count=0;
        for (int i = 0; i <chessArr.length ; i++) {
            for (int j = 0; j <chessArr[i].length ; j++) {
                if(chessArr[i][j]!=0){
                    count++;
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2]=chessArr[i][j];
                }
            }
        }
        //4.打印稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i <sparseArr.length ; i++) {
            for (int j = 0; j <sparseArr[i].length ; j++) {
                System.out.printf("%d  ",sparseArr[i][j]);
            }
            System.out.println();
        }

        /**
         * 将稀疏数组转为二维数组
         */
        System.out.println("恢复后：");
        //1.创建二维数组
        int [][]chessArr2=new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int [] row:chessArr2) {
            for (int data:row) {
                System.out.printf("%d  ",data);
            }
            System.out.println();
        }
        //2.遍历稀疏数组，给二维数组赋值
        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  ",data);
            }
            System.out.println();
        }
    }
}

四、队列

1. 基本介绍

1. 队列是有序列表，可以用数组和链表实现
2. 遵循先入先出原则。即：先存入队列的数据，要先取出。后存入的数据后取出
3. 示意图(使用数组模拟)：
   

2. 数组模拟队列

• 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如上图，MaxSize是队列最大容量。
• 因为队列的输入输出分别从前后端处理，因需要两个变量front和rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则随着数据输入而改变。
• 加入数据时“addQueue”，addQueue的处理需要两个步骤：
  • 将尾指针向后移动：rear+1
  • 若尾指针rear小于队列的最大下标MaxSize-1，则将数据存入rear所指向的数组元素中，否则无法存入数据。rear==MaxSize-1时队列满。

2.1 代码示例

/**
 * @author DELL
 * @Date 2019/12/23 17:38
 **/
public class ArrayQueueTest {
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(6);
        queue.addQueue(7);
        queue.addQueue(10);
        queue.addQueue(24);
        queue.addQueue(4);
        queue.addQueue(8);
        int q = queue.getQueue();
        int q1 = queue.getQueue();
        System.out.println(q);
        System.out.println(q1);
    }
}
class ArrayQueue{
    //数组的容量
    private int maxSize;
    //队列头
    private int front;
    //队列尾
    private int rear;
    //存放数据，模拟队列
    private int[] arr;
    public ArrayQueue(int arrMaxSize){
        this.maxSize=arrMaxSize;
        arr=new int[this.maxSize];
        this.front=-1;//指向队列头部
        this.rear=-1;//指向队列尾
    }
    //判断队列是否满
    public boolean isFull(){
        return rear==maxSize-1;
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return rear==front;
    }
    //添加数据
    public void addQueue(int n){
        //队列是否为满
        if(isFull()){
            System.out.println("队列已满，不能添加数据！");
            return;
        }
        rear++;//让rear后移
        arr[rear]=n;
    }
    //获取队列数据
    public int getQueue(){
        //判断队列是否为空
        if(isFull()){
            System.out.println("队列为空！");
        }
        front++;//front后移
        return arr[front];
    }
    //打印队列数据
    public void showQueue(){
        if(isEmpty()){
            System.out.println("队列为空！");
        }
        for (int i = 0; i <arr.length ; i++) {
            System.out.printf("arr[%d]=%d\n",i,arr[i]);
        }
    }
}

• 以上代码存在问题，当调用getQueue()函数时，front++之后数组前面的空间将会被浪费，即数组不能重复使用。

2.2 问题分析并优化

2.2.1 问题分析

1. 目前数组使用一次就不能再用，没有达到复用的效果
2. 将这个数组使用算法，改成一个环形队列：取模 %

2.2.2 优化思路

1. front变量的含义进行调整：front指向队列的第一个元素，即arr[front]为队列的第一个元素
2. rear变量的含义进行调整：rear指向队列的最后一个元素的后一个位置因为希望空出来一个空间作为约定
3. 当队列满时，条件为：(rear+1)%maxSize==front
4. 队列为空的条件，rear==front
5. 当这样分析时队列中的有效数据个数为：(rear+maxSize-front)%maxSize

2.2.3 代码示例

/**
 * @author DELL
 * @Date 2019/12/24 10:19
 **/
public class CircleQueueDemo {
    public static void main(String[] args) {
        CircleArray c = new CircleArray(6);//队列有效数据最大为5
        c.addQueue(9);
        c.addQueue(10);
        c.addQueue(4);
        c.addQueue(3);
        c.showQueue();
        try {
            int queue = c.getQueue();
            System.out.println("取出的数据为:"+queue);
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
    }
}
class CircleArray{
    private int maxSize;//数组的最大容量
    //front指向队列的第一个元素
    //front的初值为零0
    private int front;
    //rear指向队列的最后一个元素的后一个位置
    //rear的初值为0
    private int rear;
    private int [] arr;
    public CircleArray(int maxSize){
        this.maxSize=maxSize;
        arr=new int[maxSize];
        front=0;
        rear=0;
    }
    //判断队列是否满
    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=(rear+1)%maxSize;
    }
    //获取队列数据，即出队列
    public int getQueue(){
        if(isFull()){
            throw new RuntimeException("队列为空！");
        }
        //1.将front对应的值保留到一个临时变量
        //2.将front后移
        //3.将临时保留的值返回
        int value=arr[front];
        front=(front+1)%maxSize;
        return value;
    }
    //求当前队列有效数据的个数
    public int size(){
        return (rear+maxSize-front)%maxSize;
    }
    //打印队列数据
    public void showQueue(){
        if(isFull()){
            System.out.println("队列为空！");
        }
        for (int i = front; i <front+size(); i++) {
            System.out.printf("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);
        }
    }
}