线性结构
一、概念
1、线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。
2、线性结构拥有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的（这里的连续指的是物理地址连续），链式存储的线性表称为链表，链表中的存储元素不一定是连续的（物理地址不一定连续），元素节点中存放数据元素以及相邻元素的地址信息。
3、常用的线性结构有（举例）：数组、队列、栈、链表
1. 稀疏数组
一、概念
稀疏数组由来：
当一个数组中大部分元素为0，或者为同一个值得数组时，可以使用稀疏数组来保持该数组。
稀疏数组的处理方法是：
1）：记录数组一共有几行几列，有多少个不同的值。
2）：把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。
如图
如图中所示，左边为二维数组，右边为稀疏矩阵
其中稀疏矩阵第一行记录二维数组有几行几列以及非0值的个数
下边记录所有非0值的位置和值
接下来我们再来看一个图了解一下二维数组如何转换为稀疏数组，稀疏数组如何还原成二维数组
二维数组如何转换为稀疏数组
思路：
- 遍历 原始的二维数组，得到有效的个数sum。
- 根据sum就可以创建 稀疏数组 sparseArr int[sum + 1][3]。
- 将二维数组的有效数据存入到 稀疏数组。
稀疏数组如何还原成二维数组
思路：
- 先读取稀疏数组的第一行，根据第二行的数据，创建原始的二维数组，比如上面的 chessArr2 = int[11][11]
- 在读取稀疏数组后几行的数据，并赋值给 原始的二维数组即可。
```java
public class SparseArray {
public static void main(String[] args) {
/**
* 1、创建二维棋盘数组
* 其中0代表未下棋子，1代表黑棋，2代表蓝棋
*/
int chessArr1[][]=new int[11][11];
//2、向棋盘中赋予棋子
chessArr1[1][2]=1;
chessArr1[2][3]=2;
System.out.println("原始棋盘的棋子：");
for(int low[]:chessArr1) {
for(int data:low) {
System.out.printf("%d\t",data);
}
System.out.println();
}
/**
* *二维数组如何转换为稀疏数组**
思路：
1. 遍历 原始的二维数组，得到有效的个数sum。
2. 根据sum就可以创建 稀疏数组 sparseArr int[sum + 1][3]。
3. 将二维数组的有效数据存入到 稀疏数组。
*/
int sum=0;
//1. 遍历 原始的二维数组，得到有效的个数sum。
for(int i=0;i<11;i++)
for(int j=0;j<11;j++) {
if(chessArr1[i][j]!=0) {
sum++;
}
}
System.out.println("sum="+sum);
//2. 根据sum就可以创建 稀疏数组 sparseArr int[sum + 1][3]。
int sparseArr[][]=new int[sum+1][3];
//3. 将二维数组的有效数据存入到 稀疏数组。
//第一行存放棋盘数组的行列和非0值的个数
sparseArr[0][0]=11;
sparseArr[0][1]=11;
sparseArr[0][2]=sum;
//下边行存放有效值
int count=0;
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("转换后的稀疏数组为：");
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]);
}
System.out.println();
/**
* 稀疏数组还原成二维数组：
* 思路：
* 1、获取第一行存放的行列值和非0值的个数
* 2、逐行根据稀疏数组确定二维数组值的位置
*/
//1、获取第一行存放的行列值和非0值的个数
int chessArr2[][]=new int[sparseArr[0][0]][sparseArr[0][1]];
for(int i=1;i<sparseArr.length;i++) {
chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
}
System.out.println("还原后的二维数组：");
for(int low[]:chessArr2) {
for(int data:low) {
System.out.printf("%d\t",data);
}
System.out.println();
}
}
}
队列
队列介绍
1、队列是一个有序列表，可以用数组或是链表来实现。
2、遵循先入先出的原则。即 ：先存入队列的数据，要先取出。后存入的要后取出。
用数组模拟队列
1、队列本身是有序列表，若使用数组的结构来存储队列的数据，则队数组的声明如下图，其中maxSize是该队列的最大容量。
2、因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front3及rear分别记录队列前后端的下标，front会随着
3、数据输出而改变，而rear则是随着数据输入而改变，如图所示：
代码：
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(showQueue):展示队列元素");
System.out.println("a(add):向队列中加入元素");
System.out.println("h(head):获取队列的头元素");
System.out.println("g(get):从队列中取出元素");
System.out.println("e(exit):退出程序");
key=scanner.next().charAt(0);//获取系统输入的第一个字符
switch (key) {
case 's':
queue.showQueue();
break;
case 'a':
try {
System.out.println("请输入一个要插入的值：");
int val=scanner.nextInt();
queue.add(val);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'h':
try {
System.out.printf("队列的头元素：%d",queue.head());
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'g':
try {
System.out.println(queue.get());
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'e':
flag=false;
break;
default:
break;
}
}
System.out.println("程序结束~~");
}
}
//用数组模拟队列
class ArrayQueue{
int maxSize; //队列的最大元素个数
int front=-1; //队列的头指针
int rear=-1; //队列的尾指针
int arr[]; //模拟队列的数组
//创建队列构造器
public ArrayQueue(int maxSize) {
this.maxSize=maxSize;
arr=new int[maxSize];
}
//判断队列是否满
public boolean isFull() {
// 当尾指针值和数组所容纳的最大值-1相等时即满
return rear==maxSize-1;
}
//判断队列是否为空
public boolean isNull() {
//当头指针front和尾指针rear相等时，队列为空
return rear==front;
}
//向队列中加入元素
public void add(int value) {
//首先判断队列是否满
if(isFull()) {
System.out.println("队列已满");
return ;
}
//队列不满即加入
rear++;
arr[rear]=value;
}
//获取队列头元素
public int head() {
//首先判断队列是否为空
if(isNull()) {
throw new RuntimeException("队列为空");
}
return arr[front+1];
}
//从队列的取元素
public int get() {
//首先判断队列是否为空
if(isNull()) {
throw new RuntimeException("队列为空");
}
//队列不空则取出该元素
front++;
return arr[front];
}
//获取队列中所有的元素
public void showQueue() {
//首先判断队列是否为空，如果队列为空则抛出异常
if(isNull()) {
throw new RuntimeException("队列为空");
}
for (int i = 0; i < arr.length; i++) {
System.out.printf("arr[%d]=%d\t",i,arr[i]);
}
}
}
我们会发现上述队列中存在着很大的缺陷:
当从队列中取出完数据之后，front指针向后移，那么front前的那些空间会变成空（如下图所示），我们无法利用其空间，无法向其中插入数据，所以就有了下边的循环队列
循环队列
思路如下 ：
1 ： front变量的含义做一个调整 ：front就指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素
front的初始值 = 0
2 ： rear变量的含义做一个调整 ：rear指向队列的最后一个元素的后一个位置。因此希望空出一个空间做为
约定。
3 ： 当队列满时，条件是（rear + 1）% maxSize = front[满]
4 ： 当队列为的条件，rear == front空
5 ： 当我们这样分析，队列中有序的数据的个数（rear + maxSize - front）% maxSize // rear = 1 front = 0
代码实现
public class CircleArrayQueueDemo {
public static void main(String[] args) {
//测试
//创建模拟队列
CircleArrayQueue queue = new CircleArrayQueue(4);//说明：真正有效的数据为3，有一个空格作为约定
char key=' ';//用来接收用户输入的字符
Scanner scanner = new Scanner(System.in);
boolean flag=true;
while(flag) {
System.out.println("s(showQueue):展示队列元素");
System.out.println("a(add):向队列中加入元素");
System.out.println("h(head):获取队列的头元素");
System.out.println("g(get):从队列中取出元素");
System.out.println("e(exit):退出程序");
key=scanner.next().charAt(0);//获取系统输入的第一个字符
switch (key) {
case 's':
queue.showQueue();
break;
case 'a':
try {
System.out.println("请输入一个要插入的值：");
int val=scanner.nextInt();
queue.add(val);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'h':
try {
System.out.printf("队列的头元素：%d",queue.head());
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'g':
try {
System.out.println(queue.get());
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'e':
flag=false;
break;
default:
break;
}
}
System.out.println("程序结束~~");
}
}
class CircleArrayQueue{
int maxSize; //队列的最大元素个数
/**
* front变量的含义做一个调整 ：front就指向队列的第一个元素，也就是说arr【front】就是队列的第一个元素 ，front的初始值=0
*/
int front; //队列的头指针
/**
* rear变量的含义做一个调整 ：rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间做为约定。rear初始值 =0
* 队列尾
*/
int rear; //队列的尾指针
int arr[]; //模拟队列的数组
//创建循环队列构造器
public CircleArrayQueue(int maxSize) {
this.maxSize=maxSize;
arr=new int[maxSize];
}
//判断队列是否满
public boolean isFull() {
return (rear+1)%maxSize==front;
}
//判断队列是否为空
public boolean isEmpty() {
return rear==front;
}
//向队列中加入元素
public void add(int value) {
//首先判断队列是否满
if(isFull()) {
System.out.println("队列已满");
return ;
}
//先将元素加入到队列中
arr[rear]=value;
//在改变front指针的值
rear=(rear+1)%maxSize;
}
//获取队列头元素
public int head() {
//首先判断队列是否为空
if(isEmpty()) {
throw new RuntimeException("队列为空");
}
return arr[front];
}
//从队列的取元素
public int get() {
//首先判断队列是否为空
if(isEmpty()) {
throw new RuntimeException("队列为空");
}
/**
* 1、现将front位置的元素取出，将元素值赋给一个变量
* 2、front指针后移
* 3、返回该变量
* 这样做的好处：直接返回front位置的值的话，front指针没法后移
*/
int val=arr[front];
front=(front+1)%maxSize;
return val;
}
//获取队列中所有的元素
public void showQueue() {
//首先判断队列是否为空，如果队列为空则抛出异常
if(isEmpty()) {
throw new RuntimeException("队列为空");
}
for (int i = front; i < front+size(); i++) {
System.out.printf("arr[%d]=%d\t",i%maxSize,arr[i%maxSize]);
}
}
public int size() {
return (rear+maxSize-front)%maxSize;
}
}
非线性结构
非线性结构可以类比线性结构
常用的非线性结构：多维数组、广义表、树结构、图结构
其中的主要内容请参考后序博客…
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
