第3章稀疏数组与队列

参考：https://blog.csdn.net/oneby1314/category_10231585.html

1、稀疏数组

1.1 实际需求

因为该二维数组的很多值是默认值 0 ，因此记录了很多没有意义的数据，我们将其转为稀疏数组进行存储

在这里插入图片描述

1.2 稀疏数组的应用

1.2.1 稀疏数组的处理方法

稀疏数组把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
稀疏数组也是二维数组，行数由原数组的数据决定，列数一般为 3 列
稀疏数组的

第一行

记录原数组一共有几行几列，有多少个不为零的值
- 第一列：原数组的行数
- 第二列：原数组的列数
- 第三列：原数组有多少个不为零的值
之后的行记录原数组中

不为零（x）的值

所在的行数、列数以及 x 的值
- 第一列：x 在原数组中的行数
- 第二列：x 在原数组中的列数
- 第三列：x 的值

1.2.2 举例说明

原始二维数组较大，压缩后占用空间减少。

在这里插入图片描述

1.3 应用实例

1.3.1 思路分析

使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
把稀疏数组存盘，

在这里插入图片描述

1.3.2 代码实现

public class SparseArray {
    
    
    public static void main(String[] args) {
    
    
        
        // 创建一个二维数组 11*11
        // 0：表示没有棋子，1：表示 黑子，2：表示 蓝字
        int[][] chessArray1 = new int[11][11];
        chessArray1[1][2] = 1;
        chessArray1[2][3] = 2;
        // 输出原始的二维数组
        print(chessArray1);

        // 二维数组转为稀疏数组的思想
        // 1. 先遍历二维数组得到非0数据的个数
        int sum = 0;
        for (int i = 0; i < chessArray1.length; i++) {
    
    
            for (int j = 0; j < chessArray1[i].length; j++) {
    
    
                if (chessArray1[i][j] != 0) {
    
    
                    sum ++;
                }
            }
        }

        // 2. 创建对应的稀疏数组
        int[][] sparseArray = new int[sum+1][3];
        // 给稀疏数组赋值
        sparseArray[0][0] = chessArray1.length; // 原数组的行数
        sparseArray[0][1] = chessArray1[0].length; // 原数组的列数
        sparseArray[0][2] = sum;

        int count = 0; // count用于记录是第几个非0数据
        for (int i = 0; i < chessArray1.length; i++) {
    
    
            for (int j = 0 ; j < chessArray1[i].length; j++) {
    
    
                if (chessArray1[i][j] != 0) {
    
    
                    // System.out.println("不为零的数：" + chessArray1[i][j]);
                    count ++ ;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = chessArray1[i][j];
                }
            }
        }
        System.out.println("转为稀疏数组为：");
        print(sparseArray);

        // 将稀疏数组恢复为原始数组
        // 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int row = sparseArray[0][0];
        int column = sparseArray[0][1];
        int[][] initArray = new int[row][column];
        // 2. 在读取稀疏数组后几行的数据，并赋值给原始数组即可
        for (int i = 1 ; i < sparseArray.length ; i++){
    
    
            initArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        System.out.println("恢复后的数组：");
        print(initArray);
    }

    // 打印数组
    public static void print(int[][] array){
    
    
        for (int[] row : array) {
    
    
            for (int data : row) {
    
    
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }
}

2、队列

2.1 队列使用场景

银行排队的案例

在这里插入图片描述

2.2 队列的介绍

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

在这里插入图片描述

2.3、数组模拟队列

2.3.1 思路分析

maxSize ：队列容量（数组的长度）
arr ：模拟队列的数组
front ：指向队列头部元素的前一个元素，初始值为 -1
rear ：指向队列尾部元素，初始值为 -1
基本操作
- 队列判空：front == rear
- 队列判满：rear == (maxSize - 1) ，即 rear 是否已经指向了数组的最后一个位置
- 队列元素个数：rear - front
- 队列入队：队列不满才能入队，arr[++rear] = value
- 队列出队：队列不空才能出队，return arr[front++]

2.3.2 代码实现

队列的定义

// 使用数组模拟队列-编写一个ArrayQueue类
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 = front + 1; i <= rear; i++) {
      
      
			// Java 中也能用占位符诶
			System.out.printf("arr[%d]=%d\n", i, arr[i]);
		}
	}

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

测试代码

public class ArrayQueueDemo {
      
      

	public static void main(String[] args) {
      
      
		// 测试一把
		// 创建一个队列
		ArrayQueue queue = 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(get): 从队列取出数据");
			System.out.println("h(head): 查看队列头的数据");
			System.out.println();
			key = scanner.next().charAt(0);// 接收一个字符
			switch (key) {
      
      
			case 's':
				queue.showQueue();
				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;
			case 'e': // 退出
				scanner.close();
				loop = false;
				break;
			default:
				break;
			}
		}

		System.out.println("程序退出~~");
	}

}

2.3.3 数组模拟环形队列

目前数组使用一次就不能用，没有达到复用的效果，造成内存空间的浪费
将这个数组使用算法，改进成一个环形的队列（取模： %）

2.4.2 思路分析

对前面的队列进行优化，改造为环形队列（通过取模实现）
maxSize ：队列容量（数组的长度）
arr ：模拟队列的数组
front ：指向队列头部元素，初始值为 0
rear ：指向队列尾部元素的后一个元素，初始值为 0

在这里插入图片描述

基本操作

队列判空：front == rear
队列判满：
- 为何要在 rear 之后，front 之前空出一个元素的空间？因为如果不空出一个元素，队列判空条件为：front == rear ，队列判满的条件也是：front == rear ，有歧义！
- 队列容量：因为空出了一个元素，所以队列容量就变成了 (maxSize - 1)
- 当空出一个元素的空间，如何判满？当还剩一个元素时，队列就已经满了，所以判断条件为 (rear + 1) % maxSize == front
队列元数个数：
- 计算公式：(rear + maxSize - front) % maxSize ，这样来思考：
- 当 rear 比 front 大时，即 (rear -front) > 0 ，这时还没有形成环形结构，(rear -front) 即是队列元素个数
- 当 rear 比 front 小时，即 (rear -front) < 0 ，这时已经形成了环形结构，(rear -front) 表示数组还差多少个元素存满（负数），(rear + maxSize - front) 即是队列元素个数
- 综上：(rear + maxSize - front) % maxSize
队列入队：
- 首先，队列不满才能入队
- 由于 rear 指向队列尾部元素的后一个元素，所以直接设置即可： arr[rear] = value
- 接下来，rear 应该向后移动一个位置：rear = (rear + 1) % maxSize
- 取模是为了防止数组越界，让指针从新回到数组第一个元素
队列出队：
- 首先，队列不空才能出队
- 由于 front 直接指向队列头部元素，所以直接返回该元素即可：int value = arr[front ]
- 接下来，front 应该向后移动一个位置：front = (front + 1) % maxSize
- 取模是为了防止数组越界，让指针从新回到数组第一个元素

2.4.3 代码实现

环形队列的实现

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 arrMaxSize) {
      
      
		maxSize = arrMaxSize;
		arr = new int[maxSize];
	}

	// 判断队列是否满
	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("队列空，不能取数据");
		}
		// 这里需要分析出 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]);
		}
	}

	// 求出当前队列有效数据的个数
	public int size() {
      
      
		// rear = 2
		// front = 1
		// maxSize = 3
		return (rear + maxSize - front) % maxSize;
	}

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

测试代码

public class CircleArrayQueueDemo {
      
      

	public static void main(String[] args) {
      
      

		// 测试一把
		System.out.println("测试数组模拟环形队列的案例~~~");

		// 创建一个环形队列
		CircleArray queue = new CircleArray(4); // 说明设置4, 其队列的有效数据最大是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(get): 从队列取出数据");
			System.out.println("h(head): 查看队列头的数据");
			System.out.println();
			key = scanner.next().charAt(0);// 接收一个字符
			switch (key) {
      
      
			case 's':
				queue.showQueue();
				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) {
      
      
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case 'h': // 查看队列头的数据
				try {
      
      
					int res = queue.headQueue();
					System.out.printf("队列头的数据是%d\n", res);
				} catch (Exception e) {
      
      
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case 'e': // 退出
				scanner.close();
				loop = false;
				break;
			default:
				break;
			}
		}
		System.out.println("程序退出~~");
	}

}

【尚硅谷数据结构】第3章稀疏数组与队列

第3章稀疏数组与队列

1、稀疏数组

1.1 实际需求

1.2 稀疏数组的应用

1.2.1 稀疏数组的处理方法

1.2.2 举例说明

1.3 应用实例

1.3.1 思路分析

1.3.2 代码实现

2、队列

2.1 队列使用场景

2.2 队列的介绍

2.3、数组模拟队列

2.3.1 思路分析

2.3.2 代码实现

2.3.3 数组模拟环形队列

2.4.2 思路分析

2.4.3 代码实现

猜你喜欢

【尚硅谷数据结构】第3章 稀疏数组与队列

第3章 稀疏数组与队列

1、稀疏数组

1.1 实际需求

1.2 稀疏数组的应用

1.2.1 稀疏数组的处理方法

1.2.2 举例说明

1.3 应用实例

1.3.1 思路分析

1.3.2 代码实现

2、队列

2.1 队列使用场景

2.2 队列的介绍

2.3、数组模拟队列

2.3.1 思路分析

2.3.2 代码实现

2.3.3 数组模拟环形队列

2.4.2 思路分析

2.4.3 代码实现

猜你喜欢

【尚硅谷数据结构】第3章稀疏数组与队列

第3章稀疏数组与队列