建设个人网站需要备案吗培训机构管理系统

Java数据结构实现

1. 稀疏数组（Sparse Array）的实现

在实际编程中，我们经常会遇到这样的场景：一个二维数组中大部分元素都是0（或者是同一个值），只有少部分元素有不同值。这种情况下，如果我们直接存储整个二维数组，会造成极大的空间浪费。这时候，我们就可以使用稀疏数组来解决这个问题。

1.1 稀疏数组的基本概念

稀疏数组的处理方法是：

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

1.2 代码实现

public class SparseArray {public static void main(String[] args) {// 创建原始二维数组 11*11int arrays[][] = new int[11][11];// 初始化几个值arrays[1][2] = 1;arrays[2][3] = 2;arrays[5][6] = 2;// 输出原始二维数组System.out.println("原始二维数组：");for(int row[] : arrays) {for(int data : row) {System.out.printf("%d\t", data);}System.out.println();}// 统计非0值的个数int sum = 0;for(int i = 0; i < 11; i++) {for(int j = 0; j < 11; j++) {if(arrays[i][j] != 0) {sum++;}}}// 创建稀疏数组int sparse[][] = new int[sum + 1][3];// 记录原始数组的行列和有效数据个数sparse[0][0] = 11;sparse[0][1] = 11;sparse[0][2] = sum;// 将非0的值存入稀疏数组int count = 0;for(int i = 0; i < 11; i++) {for(int j = 0; j < 11; j++) {if(arrays[i][j] != 0) {count++;sparse[count][0] = i;sparse[count][1] = j;sparse[count][2] = arrays[i][j];}}}// 输出稀疏数组System.out.println("\n转换后的稀疏数组：");for(int row[] : sparse) {for(int data : row) {System.out.printf("%d\t", data);}System.out.println();}// 还原二维数组int newarrays[][] = new int[sparse[0][0]][sparse[0][1]];for(int i = 1; i < sparse.length; i++) {newarrays[sparse[i][0]][sparse[i][1]] = sparse[i][2];    }// 输出还原后的二维数组System.out.println("\n还原后的二维数组：");for(int row[] : newarrays) {for(int data : row) {System.out.printf("%d\t", data);}System.out.println();}}
}

1.3 稀疏数组实现要点

• 稀疏数组的第一行保存原始二维数组的行数、列数和有效数据个数
• 之后的每一行保存一个有效数据的行、列和值
• 还原时只需要读取稀疏数组的第一行创建原始大小的数组，然后逐个还原有效数据

2. 循环数组队列的实现

循环队列是一种线性数据结构，它的特点是把队列的首尾相连，形成一个环。这样可以更有效地利用数组空间，避免假溢出的问题。

2.1 循环队列的基本概念

• front：队列头指针，指向队列的第一个元素
• rear：队列尾指针，指向队列最后一个元素的下一个位置
• maxSize：队列的最大容量

2.2 代码实现

class CircleArray {private int maxSize;private int front;private int rear;private int[] arr;public CircleArray(int maxsize) {maxSize = maxsize;arr = new int[maxSize];// front和rear初始值为0}// 判断队列是否已满public boolean IsFulled() {return (rear + 1) % maxSize == front;}// 判断队列是否为空public boolean IsEmpty() {return rear == front;}// 添加数据到队列public void AddQueue(int n) {if(IsFulled()) {System.out.println("队列已满");return;}arr[rear] = n;rear = (rear + 1) % maxSize;}// 从队列取出数据public int GetQueue() {if(IsEmpty()) {throw new RuntimeException("队列空");}int value = arr[front];front = (front + 1) % maxSize;return value;}// 查看队列头部数据public int HeadQueue() {if(IsEmpty()) {throw new RuntimeException("队列空");}return arr[front];}// 显示队列所有数据public void ListQueue() {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;}
}

2.3 循环队列实现要点

• 队列满的条件是：(rear + 1) % maxSize == front
• 队列空的条件是：rear == front
• 队列中有效数据的个数：(rear + maxSize - front) % maxSize
• 入队和出队操作都需要使用取模运算来实现循环

2.4 队列状态图解

2.4.1 初始状态

[ ][ ][ ][ ][ ]  maxSize = 5↑
f,r说明：
- front = 0, rear = 0
- 队列为空

2.4.2 添加元素

添加元素 1, 2, 3：[1][2][3][ ][ ]↑     ↑f     r说明：
- front = 0
- rear = 3
- 有效元素个数 = 3

2.4.3 队列满状态

[1][2][3][4][ ]↑        ↑f        r说明：
- 最后一个位置必须空出来
- 满队列条件：(rear + 1) % maxSize == front

2.4.4 出队操作

初始：
[1][2][3][4][ ]↑        ↑f        r出队一个元素后：
[ ][2][3][4][ ]↑     ↑f     r说明：
- front = (front + 1) % maxSize

2.4.5 循环利用空间

初始：
[1][2][3][4][ ]↑        ↑f        r出队两个元素后：
[ ][ ][3][4][ ]↑f↑r再添加元素5：
[5][ ][3][4][ ]↑f↑r说明：
- 通过取模运算实现空间复用

2.5 核心操作解析

2.5.1 判断队列是否已满

public boolean IsFulled() {return (rear + 1) % maxSize == front;
}

示意图：
[1][2][3][4][ ]↑        ↑f        r- rear的下一个位置是front时，队列满

2.5.2 判断队列是否为空

public boolean IsEmpty() {return rear == front;
}

示意图：
[ ][ ][ ][ ][ ]↑
f,r- front和rear指向同一位置时，队列空

2.5.3 计算队列有效数据个数

public int Size() {return (rear + maxSize - front) % maxSize;
}

示意图：
[5][ ][3][4][ ]↑f↑r计算过程：
1. rear = 1
2. front = 2
3. maxSize = 5
4. (1 + 5 - 2) % 5 = 4 % 5 = 4

2.6 实际应用示例

2.6.1 数据入队过程

1. 初始状态：
[ ][ ][ ][ ][ ]↑
f,r2. 添加1：
[1][ ][ ][ ][ ]↑  ↑f  r3. 添加2：
[1][2][ ][ ][ ]↑     ↑f     r4. 添加3：
[1][2][3][ ][ ]↑        ↑f        r

2.6.2 数据出队过程

1. 初始状态：
[1][2][3][ ][ ]↑        ↑f        r2. 出队一个元素：
[ ][2][3][ ][ ]↑     ↑f     r3. 添加新元素4：
[4][2][3][ ][ ]↑     ↑f     r

总结

1. 稀疏数组的优点：

   • 节省存储空间
   • 适合处理大规模稀疏数据
   • 压缩和还原过程简单高效

2. 循环队列的优点：

   • 避免了普通队列的"假溢出"问题
   • 能够充分利用数组空间
   • 实现了队列的先进先出特性

3. 实际应用场景：

   • 稀疏数组：棋盘游戏存储、地图数据压缩等
   • 循环队列：消息队列、打印机任务队列、实时数据处理等