数据结构与算法（一）稀疏数组和队列

于 2021-11-28 21:02:16 发布
阅读量884 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46161565/article/details/121597699
版权
1、数据结构与算法的关系

（1）数据（data）结构（structure）是一门研究组织数据方式的学科，有了编程语言也就有了数据结构，学好数据结构可以编写出更加漂亮的、更加有效率的代码

（2）要学好数据结构就要多考虑如何将生活中遇到的问题，用程序去实现解决

（3）程序 = 数据结构 + 算法

（4）数据结构是算法的基础

2、线性结构

（1）线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系

（2）线性结构有两种不同的存储结构，即顺序存储结构（数组）和链式存储结构（链表）。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的

（3）链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻的元素的地址信息

（4）线性结构常见的有：数组、队列、链表和栈

3、非线性结构

非线性结构包括：二维数组，多维数组，广义表，树结构，图结构

4、稀疏数组

4.1 先看一个实际的需求

在五子棋游戏中，有存盘和接上盘的功能

因为该二维数组有很多的默认数据都为0，因此记录了很多没有意义的数据

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

4.2 稀疏数组的处理方法是：

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

（2）把具有不同值的元素的行和列以及值记录在一个小规模的数组中，从而缩小数据的规模

4.3 思路

二维数组 转 稀疏数组的思路

（1） 遍历 原始的二维数组，得到有效数据的个数 sum

（2）根据sum 就可以创建 稀疏数组 sparseArr int[sum + 1] [3]

（3）将二维数组的有效数据数据存入到 稀疏数组

稀疏数组转原始的二维数组的思路

（1）先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11]

（2） 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.

代码实现：

package com.cyk.sparsearray;

import java.io.*;

public class SparseArray {
    public static void main(String[] args) {
        // 创建一个原始的二维数组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();
        }

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

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

        //给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        //遍历二维数组，将非零的数据放到稀疏数组中
        int count = 0;//count用于记录是第几个非零元素
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr1[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }

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

        //TODO 将稀疏数组保存到文件中

        //TODO 读取稀疏数组

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

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

        //3、输出恢复后的二维数组
        System.out.println();
        System.out.println("恢复后的二维数组为：");
        for (int[] row : chessArr2) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

    }
}
5、队列

5.1 队列介绍

（1）队列是一个有序列表，可以用数组或是链表来实现

（2）遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出

（3）示意图：（使用数组模拟队列示意图）

5.2 数组模拟队列的思路

（1）队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize是该 队列的最大容量

（2）因为队列的输出、输入是分别从前后端来处理因此需要两个变量front及rear分别记录队列前后端的下标， front会随着数据输出而改变，而rear则是随着数据输入而改变，如图所示：

（3）当我们将数据存入队列时称为"addQueue"，addQueue的处理需要有两个步骤，思路分析：

​ ①将尾指针往后移：rear+1，当front==rear时，队列为空

​ ②若尾指针rear小于队列的最大下标maxSize-1，则将数据存入rear所指的数据元素中，否则无法存入数据

​ 当rear==maxSize-1时，队列满

（4）代码实现：

package com.cyk.queue;

import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
        //创建一个队列
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' ';//接收用户的输入
        Scanner scanner = new Scanner(System.in);
        boolean flag = true;
        while (flag) {
            System.out.println("s(show)：显示队列的所有数据");
            System.out.println("e(exit)：退出");
            System.out.println("a(add)：添加数据到队列");
            System.out.println("g(get)：获取队列的数据");
            System.out.println("h(head)：显示队列的头数据");
            key = scanner.next().charAt(0);//接收一个字符
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    flag = false;
                    break;
                case 'a':
                    System.out.println("输入一个数字：");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是：%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是：%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

//使用数组模拟队列
class ArrayQueue {
    private int maxSize;//表示数组的最大容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//该数组用于存放数据，模拟队列

    //创建队列
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1;//指向队列头部，front是指向队列头的前一个位置
        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 (isEmpty()) {
            //通过抛出异常处理
            throw new RuntimeException("队列空，不能取数据");
        }
        front++;//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 headQueue() {
        //判断是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        return arr[front + 1];
    }
}

5.3 问题分析并优化

（1）目前数组使用一次就不能再继续使用，没有达到服用的效果

（2）将这个数组使用算法，改进成一个环形队列（取模：%）

5.4 数组模拟环形队列

（1）对前面的数组模拟队列的优化，充分利用数组，因此将数组看作是一个环形的。（通过取模的方式来实现）

（2）分析说明：

​ ①尾索引的下一个为头索引时表示队列满，即：将队列容量空出一个作为约定，这个在做判断队列满的时候 需要注意 (rear+1) % maxSize == front（队列满）

​ ②rear == front（队列为空）

​ ③分析示意图：

（3）思路如下：

​ ①front 变量的含义做一个调整：front 就指向队列的第一个元素，也就是说 arr[front] 就是队列的第一个元 素，front 的初始值 = 0

​ ② rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置， 因为希望空出一个空间做为 约定，rear 的初始值 = 0

​ ③当队列满时，条件是 (rear + 1) % maxSize == front （队列满）

​ ④对队列为空的条件，rear == front （队列为空）

​ ⑤当我们这样分析，队列中有效的数据的个数 (rear + maxSize - front) % maxSize // rear = 1 front = 0

​ ⑥我们就可以在原来的队列上修改得到一个环形队列

（4）代码实现：

package com.cyk.queue;

import java.util.Scanner;

public class CircleArrayQueue {
    public static void main(String[] args) {
        //创建一个环形队列
        CircleArray queue = new CircleArray(4);//队列的有效数据最大是3
        char key = ' ';//接收用户的输入
        Scanner scanner = new Scanner(System.in);
        boolean flag = true;
        while (flag) {
            System.out.println("s(show)：显示队列的所有数据");
            System.out.println("e(exit)：退出");
            System.out.println("a(add)：添加数据到队列");
            System.out.println("g(get)：获取队列的数据");
            System.out.println("h(head)：显示队列的头数据");
            key = scanner.next().charAt(0);//接收一个字符
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    flag = false;
                    break;
                case 'a':
                    System.out.println("输入一个数字：");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是：%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是：%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

//使用环形数组模拟队列
class CircleArray {
    private int maxSize;//表示数组的最大容量
    private int front;//队列头，front指向队列的第一个元素，也就是arr[front]，front的初始值 = 0
    private int rear;//队列尾，rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定，rear的初始值 = 0
    private int[] arr;//该数组用于存放数据，模拟队列

    //创建队列
    public CircleArray(int arrMaxSize) {
        maxSize = arrMaxSize;
        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 (isEmpty()) {
            //通过抛出异常处理
            throw new RuntimeException("队列空，不能取数据");
        }
        //1、先把front对应的值保存到一个临时变量，直接返回的话front就没有后移的机会了
        int value = arr[front];
        //2、将front后移，要考虑取模
        front = (front + 1) % maxSize;
        //3、将临时保存的变量返回
        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 headQueue() {
        //判断是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        return arr[front];
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值