一、概念
1、线性结构作为最常用的数据结构,其特点是数据元素之间存在一对一的线性关系。
2、线性结构拥有两种不同的存储结构,即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表,顺序表中的存储元素是连续的(这里的连续指的是物理地址连续),链式存储的线性表称为链表,链表中的存储元素不一定是连续的(物理地址不一定连续),元素节点中存放数据元素以及相邻元素的地址信息。
3、常用的线性结构有(举例):数组、队列、栈、链表
一、概念
稀疏数组由来:
当一个数组中大部分元素为0,或者为同一个值得数组时,可以使用稀疏数组来保持该数组。
稀疏数组的处理方法是:
1):记录数组一共有几行几列,有多少个不同的值。
2):把具有不同值的元素的行列及值记录在一个小规模的数组中,从而缩小程序的规模。
如图
如图中所示,左边为二维数组,右边为稀疏矩阵
其中稀疏矩阵第一行记录二维数组有几行几列以及非0值的个数
下边记录所有非0值的位置和值
接下来我们再来看一个图了解一下二维数组如何转换为稀疏数组,稀疏数组如何还原成二维数组
二维数组如何转换为稀疏数组
思路:
稀疏数组如何还原成二维数组
思路:
```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
队列介绍
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;
}
}
非线性结构可以类比线性结构
常用的非线性结构:多维数组、广义表、树结构、图结构
其中的主要内容请参考后序博客…