老韩图解Java数据结构和算法-第三章稀疏数组和队列

最新推荐文章于 2024-07-30 23:45:31 发布
最新推荐文章于 2024-07-30 23:45:31 发布
阅读量209 收藏 1
点赞数
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_32498953/article/details/112526573
版权
本文介绍了稀疏数组的概念和应用场景，通过实例演示了如何利用稀疏数组存储和恢复二维数组，以节省存储空间。此外，还详细讲解了队列的基本原理、数组模拟队列的方法及其优化过程，最终实现了环形队列。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

3.1 稀疏 sparsearray 数组

3.1.1 一个实际的需求

  • 编写的五子棋程序中，有存盘退出和续上盘的功能。
    五子棋
  • 分析问题：

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

3.1.2基本介绍

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

稀疏数组得处理方式是：

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

  • 稀疏数组的举例说明

二维数组：会存在大部分重复的元素0
二维数组

稀疏数组：第一行记录一共有几行几列，有多少个不同的值，第二行开始记录不同的值所在的位置，减少重复的数据，从而缩小程序的规模。
稀疏数组

3.1.3 应用实例

1）使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
2）把稀疏数组存盘，并且可以重新恢复原来的二维数组
3）整体思路分析

稀疏数组

  • 二维数组转稀疏数组的思路
  1. 遍历 原始的二维数组，得到有效数据的个数 sum；
  2. 根据sum就可以创建 稀疏数组 sparseArr int[sum+1][3]；
  3. 将二维数组的有效数据存入到稀疏数组；
  • 稀疏数组转原始的二维数组的思路
  1. 先读取稀疏数组的第一行，根据第一行的数据，创建元素的二维数组，比如 上面的sparseArr [11][11]；
  2. 在读取稀疏数组后几行的数据，并赋给元素的二维数组即可；

代码实现

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.先遍历二维数组，得到非0数据的个数
        int sum = 0;
        int col = 0;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    sum++;
                }
                if (col == 0) {
                    col = chessArr1[i].length;
                }
            }
        }
        System.out.println(sum);
        // 2.来创建一个对应的稀疏数组
        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = chessArr1.length;
        sparseArray[0][1] = col;
        sparseArray[0][2] = sum;
        int count = 1;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; 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[] rows : sparseArray) {
            for (int row : rows) {
                System.out.printf("%d\t", row);
            }
            System.out.println();
        }
        // 将稀疏数组恢复成原始的数组
        // 1. 先读取稀疏数组的第一行，根据第一行的数据，创建元素的二维数组，比如 上面的sparseArr [11][11]；
        int chessArr2[][] = new int[sparseArray[0][0]][sparseArray[0][1]];
        // 2. 在读取稀疏数组后几行（第二行）的数据，并赋给元素的二维数组即可；
        for (int i = 1; i < sparseArray.length; i++) {
            chessArr2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        System.out.println();
        System.out.println("恢复后的二维数组");
        for (int[] row : chessArr2) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }
}

3.1.4 课后练习

要求：

  1. 在前面的基础上，将稀疏数组保存在磁盘上
  2. 在恢复原来的数组时，读取磁盘的数据

代码实现

public class SparseArray {
    /**
     * 文件路径
     */
    private static String filePath = "E:/sparseArray.txt";

    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.先遍历二维数组，得到非0数据的个数
        int sum = 0;
        int col = 0;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    sum++;
                }
                if (col == 0) {
                    col = chessArr1[i].length;
                }
            }
        }
        System.out.println(sum);
        // 2.来创建一个对应的稀疏数组
        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = chessArr1.length;
        sparseArray[0][1] = col;
        sparseArray[0][2] = sum;
        int count = 1;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; 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[] rows : sparseArray) {
            for (int row : rows) {
                System.out.printf("%d\t", row);
            }
            System.out.println();
        }
        // 从文件中读取
        int[][] sparseArrayTemp = getSparseArray();
        if (sparseArrayTemp[0][0] != -1) {
            // 使用读取出来的稀疏数组
            sparseArray = sparseArrayTemp;
            System.out.println("使用读取出来的稀疏数组");
        }
        // 将稀疏数组恢复成原始的数组
        // 1. 先读取稀疏数组的第一行，根据第一行的数据，创建元素的二维数组，比如 上面的sparseArr [11][11]；
        int chessArr2[][] = new int[sparseArray[0][0]][sparseArray[0][1]];
        // 2. 在读取稀疏数组后几行（第二行）的数据，并赋给元素的二维数组即可；
        for (int i = 1; i < sparseArray.length; i++) {
            chessArr2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        System.out.println();
        System.out.println("恢复后的二维数组");
        for (int[] row : chessArr2) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        if (writeSparseArray(sparseArray)) {
            System.out.println("稀疏数组写入成功");
        } else {
            System.out.println("稀疏数组写入失败");
        }
    }

    /**
     * <p>将稀疏数组写入到磁盘
     * 如下格式
     * 11,11,3:1,2,1:2,3,2:4,5,2
     * </p>
     *
     * @param sparseArray 稀疏数组
     * @return boolean true 写入成功 false 写入失败
     * @date 2021/1/17 16:10
     * @since 0.0.1
     */
    private static boolean writeSparseArray(int[][] sparseArray) {
        try {
            // 判断是否有该文件
            File file = new File(filePath);
            if (!file.getParentFile().exists()) {
                file.mkdirs();
            }
            if (!file.exists()) {
                file.createNewFile();
            }
            FileWriter fileWriter = new FileWriter(filePath);
            // 遍历稀疏数组将其写入文件并通过每个通过,逗号隔开，每行通过*号隔开
            StringBuffer temp = new StringBuffer();
            for (int i = 0; i < sparseArray.length; i++) {
                for (int j = 0; j < sparseArray[i].length; j++) {
                    if (j + 1 != sparseArray[i].length) {
                        temp.append(String.format("%s%s", sparseArray[i][j], ","));
                    } else {
                        temp.append(String.format("%s", sparseArray[i][j]));
                    }
                }
                if (i + 1 != sparseArray.length) {
                    temp.append(":");
                }
            }
            String sparseArrayStr = temp.toString();
            if (!"".equals(sparseArrayStr)) {
                fileWriter.write(sparseArrayStr);
            }
            fileWriter.close();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * <p>获取磁盘文件中的稀疏数据</p>
     *
     * @return 稀疏数组，如果失败 sparseArray[0][0] = -1 为标记
     * @date 2021/1/17 17:18
     * @since 0.0.1
     */
    private static int[][] getSparseArray() {
        File file = new File(filePath);
        int[][] sparseArray = new int[1][1];
        sparseArray[0][0] = -1;
        if (!file.exists()) {
            return sparseArray;
        }
        // 解析文件
        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
            // 就一行
            String sparseArrayStr = bufferedReader.readLine();
            //算出行
            String[] rows = sparseArrayStr.split(":");
            sparseArray = new int[rows.length][3];
            for (int i = 0; i < rows.length; i++) {
                String[] values = rows[i].split(",");
                for (int j = 0; j < values.length; j++) {
                    sparseArray[i][j] = Integer.valueOf(values[j]);
                }
            }
            return sparseArray;
        } catch (Exception e) {
            e.printStackTrace();
            sparseArray[0][0] = -1;
            return sparseArray;
        }
    }
}

代码输出

原始的二维数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	2	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
3

得到的稀疏数组为如下形式
11	11	3	
1	2	1	
2	3	2	
4	5	2	
使用读取出来的稀疏数组

恢复后的二维数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	2	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
稀疏数组写入成功

3.2 队列

3.2.1 对列的一个使用场景

银行排队的案例：
对列的一个使用场景

3.2.2 队列介绍

1）队列是一个有序列表，可以用数组或是链表来实现。
2）遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的后取出。
3）示意图：（使用数组模拟对列示意图）
列队示意图

3.2.3 数组模拟队列思路

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

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

列队示意图
3）当我们将数据存入队列是称为"addQueue"，addQueue的处理需要又两个步骤：思路分析

  • 将尾指针往后移：rear+1，当front==rear 为空；
  • 若指针rear小于队列的最大下标 maxSize-1，则将数据存入rear所指的数组元素中，否则无法存入数据。rear===maxSize-1【队列满】；

代码实现

package com.panhu.queue;

import java.util.Scanner;

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

                    break;
                case 'h':
                    try {
                        int res = arrayQueue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~");
    }
}

/**
 * 使用数组模拟队列-编写一个ArrayQueue的类
 */
class ArrayQueue {
    /**
     * 表示数组的最大容量
     */
    private int maxSize;
    /**
     * 队列头
     */
    private int front;
    /**
     * 队列尾
     */
    private int rear;
    /**
     * 改数据用于存放数据，模拟队列
     */
    private int[] arr;

    /**
     * 构造队列的构造器
     *
     * @param maxSize 最大的容量
     */
    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
        // 指向队列头部，front是指向队列的前一个位置。
        front = -1;
        // 指向队列尾部，rear是指向队列尾的数据（即就是队列最后一个数据）
        rear = -1;
    }

    /**
     * 判断队列是否满
     *
     * @return boolean true 满 false 未满
     */
    public boolean isFull() {
        return rear == maxSize - 1;
    }

    /**
     * 判断队列是否为空
     *
     * @return boolean true 空 false 不是空
     */
    public boolean isEmpty() {
        return rear == front;
    }

    /**
     * 添加数据
     *
     * @param n 数据
     */
    public void addQueue(int n) {
        // 判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据");
            return;
        }
        // rear 后移
        rear++;
        arr[rear] = n;
    }

    /**
     * 获取队列的数据
     *
     * @return 获取的数据
     */
    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]);
        }
    }

    /**
     * 显示队列的头数据，注意不是取出数据
     *
     * @return 第一个数据
     */
    public int headQueue() {
        // 判断是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列空的，没有数据~~");
        }
        return arr[front + 1];
    }
}

代码输出

s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
10
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[0]=10
arr[1]=0
arr[2]=0
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
20
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[0]=10
arr[1]=20
arr[2]=0
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[0]=10
arr[1]=20
arr[2]=30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
4
队列满，不能加入数据
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[0]=10
arr[1]=20
arr[2]=30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
h
队列头的数据是10
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
h
队列头的数据是10
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
g
取出的数据是10
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
h
队列头的数据是20
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
g
取出的数据是20
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
g
取出的数据是30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
g
队列空，不能取数据
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据

4）问题分析并优化

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

3.2.4 数组模拟环形队列

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

  • 分析说明

1）rear的下一个front是表示队列满（rear与front相邻），即将队列的容量空出一个作为约定(rear在队列最后一个前一位，front在最前一位的这种情况)，这个在做判断满的时候公式为（rear+1）%maxSize=front，其中(rear+1)表示相邻，%maxSize为取模算出真实的位置，例如一个长度为5的环形数组，队列的容量空出一个作为约，front在3，rear在6（第二圈的2），为了统一所以需要取余。

2）rear == front 为空

3）分析示意图
环形队列分析示意图

  • 思路如下

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

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

3）当队列满时，条件时（rear+1）%maxSize=front[满]；

4）队列为空的条件，rear==front [空]；

5）当我们这样分析，队列中有效的数据的个数公式为：(rear+maxSize-front)%maxSize

代码实现

package com.panhu.queue;

import java.util.Scanner;

/**
 * @author LanChaoHui
 * @version 0.0.1
 * @Type com.panhu.queue.CircleArrayQueueDemo.java
 * @date 2021/2/25 11:37
 */
public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        System.out.println("测试数组模拟环形队列的案例~~~");
        // 创建一个队列，这里设置4，其队列最大的有效空间为3
        CircleArray circleArray = new CircleArray(4);
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop) {
            System.out.println("s(show)：显示队列");
            System.out.println("e(exit)：退出队列");
            System.out.println("a(add)：添加数据到队列");
            System.out.println("g(show)：从队列中取数据");
            System.out.println("h(head)：查看队列头的数据");
            // 接收一个字符
            key = scanner.next().charAt(0);
            switch (key) {
                case 's':
                    circleArray.showQueue();
                    break;
                case 'a':
                    System.out.println("请输入一个数字");
                    int value = scanner.nextInt();
                    circleArray.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = circleArray.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                    break;
                case 'h':
                    try {
                        int res = circleArray.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~");
    }
}

class CircleArray {
    /**
     * 表示数组的最大容量
     */
    private int maxSize;
    /**
     * front 变量的含义做一个调整：front就指向队列的第一个元素也就是arr[front]
     * front 的初始值 = 0
     */
    private int front;
    /**
     * rear 变量的含义做一个调整：rear 指向队列的最后一个元素的前一个位置，因为希望空出一个位置作为约定
     * rear 的初始值 = 0
     */
    private int rear;
    /**
     * 改数据用于存放数据，模拟队列
     */
    private int[] arr;

    public CircleArray(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
    }

    /**
     * 判断队列是否满
     *
     * @return boolean true 满 false 未满
     */
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    /**
     * 判断队列是否为空
     *
     * @return boolean true 空 false 不是空
     */
    public boolean isEmpty() {
        return rear == front;
    }

    /**
     * 添加数据
     *
     * @param n 数据
     */
    public void addQueue(int n) {
        // 判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据");
            return;
        }
        // 直接加人
        arr[rear] = n;
        // 将rear后移，这里必须考虑取模
        rear = (rear + 1) % maxSize;
    }

    /**
     * 获取队列的数据
     *
     * @return 获取的数据
     */
    public int getQueue() {
        if (isEmpty()) {
            // 通过抛出异常
            throw new RuntimeException("队列空，不能取数据");
        }
        // 这里需要分析出front时指向队列的第一个的的元素
        // 1. 先将front对应的值保留到一个临时变量
        // 2. 将front 后移动，考虑取模
        // 3. 将临时保存的办理返回
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

    /**
     * 显示队列所有的数据
     */
    public void showQueue() {
        // 遍历
        if (isEmpty()) {
            System.out.println("队列空的，没有数据~~");
            return;
        }
        // 思路：从front开始变量，遍历多少个元素
        for (int i = front; i < (front + size()); i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }

    /**
     * 求出当前队列有效的数据个数
     *
     * @return 有效个数
     */
    public int size() {

        return (rear + maxSize - front) % maxSize;
    }

    /**
     * 显示队列的头数据，注意不是取出数据
     *
     * @return 第一个数据
     */
    public int headQueue() {
        // 判断是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列空的，没有数据~~");
        }
        // front 指向队列的第一个元素
        return arr[front];
    }
}

代码输出

测试数组模拟环形队列的案例~~~
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
队列空的，没有数据~~
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
10
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[0]=10
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
20
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[0]=10
arr[1]=20
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
40
队列满，不能加入数据
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
g
取出的数据是10
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[1]=20
arr[2]=30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[1]=20
arr[2]=30
arr[3]=30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
70
队列满，不能加入数据
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
h
队列头的数据是20
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
g
取出的数据是20
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
g
取出的数据是30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
g
取出的数据是30
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
队列空的，没有数据~~
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
50
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
60
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[0]=50
arr[1]=60
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
70
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[0]=50
arr[1]=60
arr[2]=70
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
g
取出的数据是50
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[1]=60
arr[2]=70
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
a
请输入一个数字
80
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
s
arr[1]=60
arr[2]=70
arr[3]=80
s(show)：显示队列
e(exit)：退出队列
a(add)：添加数据到队列
g(show)：从队列中取数据
h(head)：查看队列头的数据
e
程序退出~~
跟老韩学JAVA——入门篇
langezuibang的博客
03-17 1288
JAVA的由来 Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的高级程序设计语言。 特点： 1、Java语言是面向对象的（OOP）； 2、Java语言是健壮的，Java的强制类型机制、异常处理、垃圾的自动收集等； 3、Java语言是编译和解释型的； （解释性语言：javascript,PHP,java 编译性语言：c,c++ 区别：解释性语言，编译后的代码，不能直接被机器执行，需要解释器来执行，编译性语言，编译后的代码，可以直接被机器执行.) 4、Java语言是
最新JAVA数据结构算法视频教程全套20课
weixin_44216004的博客
12-25 2327
课程目录： 第一讲数组 第二讲简单排序 第三讲栈和队列 第四讲链表 第五讲双端链表和双向链表 第六讲递归的应用 第七讲递归的高级应用 第八讲希尔排序 第九讲快速排序 第十讲二叉树的基本概念 ........ 19第十九讲：图的搜索 第二十讲：图的最小生成树       下载地址：百度网盘...
老韩图解Java数据结构和算法笔记-第二章 数据结构和概述
LanChaoHui的博客
01-12 393
数据结构和算法的介绍 数据结构和算法的关系 数据结构(data)是一门研究(structure)组织数据方式的学科，有了编程也就有了数据结构。学号数据结构可以编写出更加漂亮，更加有效率的代码。 要学习好数据结构就要多多考虑如何将生活中遇到的问题，用程序去实现解决。 程序=数据结构+算法 数据结构是算法的接触，换言之，想学好算法，需要把数据结构学到位。 ...
图解Java数据结构和算法
m0_46238194的博客
02-18 335
老韩图解Java数据结构和算法-结束语(卖油翁和老黄牛).avi 老韩图解Java数据结构和算法-骑士周游回溯算法用贪心算法优化.avi 老韩图解Java数据结构和算法-骑士周游回溯算法代码实现(3).avi 老韩图解Java数据结构和算法-骑士周游回溯算法代码实现(2).avi 老韩图解Java数据结构和算法-骑士周游回溯算法代码实现(1).avi 老韩图解Java数据结构和算法-骑士周游问题思...
java集合--- 老韩
weixin_44761821的博客
11-04 887
java集合—尚硅谷 Collection 接口 遍历原始 使用 的 是 迭代器 Iterator（迭代器） 1.Iterator 对象 称为 迭代器， 主要 用于 Collection 集合中的 元素 2. 实现了 Collection 接口 的 集合类 都有 一个 iterator（），用于 返回 实现了 Iterator 接口的对象 即可以返回 一个 迭代器 3. Iterator 仅用于 遍历集合 ，本身 不存放对象 迭代器的 原理 ： Iterator iterator(
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
2019韩顺平图解Java数据结构和算法项目实战教程(完整)
weixin_44976902的博客
06-19 7366
老韩图解Java数据结构和算法-结束语(卖油翁和老黄牛).avi 老韩图解Java数据结构和算法-骑士周游回溯算法用贪心算法优化.avi 老韩图解Java数据结构和算法-骑士周游回溯算法代码实现(3).avi 老韩图解Java数据结构和算法-骑士周游回溯算法代码实现(2).avi 老韩图解Java数据结构和算法-骑士周游回溯算法代码实现(1).avi 老韩图解Java数据结构和算法-骑士周游问题思...
尚硅谷老韩java版算法和数据结构讲解代码笔记整理.zip
01-14
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
尚硅谷老韩讲解Java算法与数据结构代码笔记
资源摘要信息: "尚硅谷老韩java版算法和数据结构讲解代码笔记整理" 知识点详细说明： 一、数据结构（Data Structures） 1. 逻辑结构 数据结构的逻辑结构是指数据元素之间逻辑上的关系，它独立于数据元素在计算机...
老韩的java基础笔记
03-27
1.1.3 第三阶段：高级特性，涵盖异常处理、文件I/O、集合框架、多线程、网络编程等。 - **1.1.2 关于课程的说明** 课程注重理论与实践相结合，每个知识点都配有实例解析，确保学生能够理解并运用到实际项目中。 ...
《Java数据结构和算法第二版》（附源码）
06-02
这本书作者是Robert Lafore先生，通俗易懂，对于在计算机应用中如何操作和管理数据以取得最优性能提供了深入浅出的讲解。全书分别讲述了数组、简单排序、基本概念、二叉树、红黑树、堆和队列、链表、递归、进阶排序、哈希表及图形等知识。附录中则提供了运行专题Applet和例程、相关书籍和问题解答。
老韩Java第八章作业汇总(自做)
执念斩长河
01-04 381
先把作业打下来，然后一题题做。
【跟着老韩学Java】房屋管理系统
DJYTiao的博客
07-22 408
对于计算机的学习，在编程语言方面我打算先熟练使用Java，在B站上找了一套教程——），我认为这可以称得上是最好的零基础Java课程了，真就是手把手教你，老韩会一行一行代码敲出来，让新手能够慢慢理解。而且老韩不仅仅是教导编程技巧，他真的像你的老师一样，会教你学习的心法，每次中途学累了，总会听到老韩的“别着急，慢慢来，都能学好，都能学会”“业精于勤，荒于嬉。”“我亦无他，唯手熟尔。”内心总会重归平静，充满力量。尽管素未谋面，老韩是我人生中一位重要的人生导师，无需多言，谁看谁知道，谁看谁赚到。
韩老师Java第11章课程笔记
执念斩长河
01-09 243
本博文源于老韩java30天，本博文讲述自定义类实现枚举、enum关键字实现枚举、JDK内置基本注解类型与元注解。
【跟着老韩学Java】匿名内部类
最新发布
DJYTiao的博客
07-30 233
使用匿名内部类可以用来一次性的创建一个继承父类或实现接口的子类并自定义重写或实现其中的方法，很方便。jdk底层在创建匿名内部类的时候会分配一个隐匿的类名（外部类$n）在创建对象后匿名内部类即被废弃。匿名内部类继承父类或实现接口，用父类或接口的引用接受匿名内部类的对象。此时对象的编译类型就是父类或接口的类型，而编译类型则是匿名内部类。匿名内部类是为了只用一次临时类的情况，来简化开发。匿名内部类定义在外部类的局部位置，而且没有类名。定义匿名内部类之后立刻创建一个对象。其他很多特性和局部内部类很相近。
对韩java_跟着老韩学Java之JDBC概述
weixin_34646207的博客
02-20 367
前面我们讲过，JDBC是JavaEE的一个重要技术，那么它到底是什么呢？老韩今天就对JDBC来做个概述。1、JDBC简介；JDBC(Java DataBase Connectivity)是Java与数据库的接口规范，由Java 语言编写的类和接口组成，我们可以直接使用这些类和接口来访问数据库获取资源，不管你是什么数据库，只要JDBC提供的有接口，我就可以进行通信，我不需要直接对接数据库，我只对接J...
JAVA数据结构和算法系列视频教程 20课
qq_42798014的博客
07-27 6086
课程介绍:基于JAVA语言的数据结构算法视频教程，非常经典的java数据结构基础理论课程，是学习java的必备技能。课程目录:01.第一讲数组02.第二讲简单排序03.第三讲栈和队列04.第四讲链表05.第五讲双端链表和双向链表06.第六讲递归的应用07.第七讲递归的高级应用08.第八讲希尔排序09.第九讲快速排序10.第十讲二叉树的基本概念11.第十一讲二叉树的基本操作12.第十二讲遍历二叉树1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值