数据结构与算法
1.线性结构与非线性结构
1. 线性结构特点是数据元素之间存在一对一的线性关系，具有两种不同的存储结构，即顺序存储结构和链式存储结构，顺序存储结构为顺序表（数组），链式存储结构（链表）
2. 线性结构常见的有：数组，队列，链表和栈；非线性结构包括：二维数组，多为数组，广义表，树结构，图结构
2.稀疏数组
因为棋盘上很多只默认为0，记录其值无意义。因此采用稀疏数组的方式记录、保存棋盘。
棋盘共有6行7列。稀疏数组行数由棋盘中非0的值的个数决定，第0行保存原始数组的行数，列数，以及有效值的个数。3列分别为：“值所在的行”，“值所在的列”，“值”。原棋盘中为42个数据，而稀疏数组中只需要27个数据，实现了数据压缩后的保存。
2.1 二维数组转化为稀疏数组的思路：
- 遍历原始的二维数组，得到有效的数据的个数sum
- 根据sum创建稀疏数组sparseArr int [sum+1] [3]
- 将二维数组的有效数据存入到稀疏数组中
2.2 稀疏数组转化为二维数组的思路：
- 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2 = int [11] [11]
- 在读取稀疏数组的数据后，赋值给原始的二维数组即可
public class LessArray {
public static void main(String[] args) {
//创建一个原始的二维数组 11*11
//0表示没有棋子，1表示黑子，2表示白子
//创建棋盘数组
int chessArr1[] [] = new int [11] [11];
//棋盘赋值
chessArr1[1][2] = 1;
chessArr1[2][4] = 2;
int sum = 0;
//取出数组里的每一行遍历，打印棋牌数组
System.out.println("原始的二维数组：");
for (int [] row: chessArr1) {
for(int data: row){ //取出每一行里的每一个数据进行遍历
System.out.printf("%d\t",data);
}
System.out.println();
}
//计算棋盘数组中的有效数据
for (int i = 0; i <11 ; i++) {
for (int j = 0; j < 11; j++) {
if(chessArr1[i][j]!=0){
sum++;
}
}
}
//创建稀疏数组并且对第一行进行赋值
int sparseArr[][] = new int[sum+1][3];
sparseArr[0][0] = 11;
sparseArr[0][1] = 11;
sparseArr[0][2] = sum;
//传递非0值到稀疏数组
//将棋盘数组对二维数组进行转化
//记录是第几个非0数据
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();
//将稀疏数组转换为棋盘数组，根据稀疏数组的第一行创建棋盘数组的第一行
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];
}
//打印稀疏数组
for (int [] row:chessArr2) {
for(int data:row){
System.out.printf("%d\t",data);
}
System.out.println();
}
}
}
3.队列
3.1队列是一个有序链表，可以用数组或链表来实现，遵循先入先出原则，即先存入的数据先取出，后存入的数据后取出。类似于横放的自来水管。
取值时front向上移动一位，加入一个值时rear向上移动一位。
import jdk.internal.org.objectweb.asm.tree.TryCatchBlockNode;
import java.time.temporal.ValueRange;
import java.util.Scanner;
public class ArrayQueueDemo {
public static void main(String[] args) {
//创建队列对象
ArrayQueue arrayQueue = new ArrayQueue(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(get):取出队列");
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 'e':
scanner.close();
loop = false;
break;
case 'h':
try {
int res = arrayQueue.HeadQueue();
;
System.out.printf("头部的数据是：%d\n", res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'g':
try {
int res = arrayQueue.getNumber();
System.out.printf("取出的数据是：%d\n", res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
default:
break;
}
}
System.out.println("程序退出~~~");
}
}
//使用数组模拟队列
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; // 指向队列数据头部的前一个位置
rear = -1; // 指向队列数据尾部（即就是队列的最后一个数据）
}
//判断队列是否满了
public boolean isFull() {
return rear == maxSize - 1;
}
//队列是否为空
public boolean isEmpty() {
return rear == front;
}
//添加数据
public void addQueue(int n) {
while (isFull()) {
System.out.println("队列已满，不能加入数据");
return;
}
rear++; //让rear先往上加一个单位，因为不移动前指的是当前数据的位置，
// 如果不移动则不是添加数据，而是把原来的值给覆盖了
arr[rear] = n;
}
//取出数据
public int getNumber() {
while (isEmpty()) {
throw new RuntimeException("队列为空,不能取数据");
}
front++; //指向的是当前数据的前一个位置，并不是当前数据的位置，
// 如果要取出数据，需要将指针上移一个单位
return arr[front];
}
//获取头部数据
public int HeadQueue() {
if (isEmpty()) {
throw new RuntimeException("队列为空，没有数据");
}
return arr[front + 1];
}
public void showQueue() {
if (isEmpty()) {
System.out.println("队列为空，没有数据");
}
for (int i = 0; i < arr.length; i++) {
System.out.printf("arr[%d]=%d\n", i, arr[i]);
}
}
}
优化：调整为循环队列
import java.security.PublicKey;
import java.util.Scanner;
public class CircleArrayQueue {
public static void main(String[] args) {
//创建队列对象
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(get):取出队列");
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 'e':
scanner.close();
loop = false;
break;
case 'h':
try {
int res = circleArray.HeadQueue();
;
System.out.printf("头部的数据是：%d\n", res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'g':
try {
int res = circleArray.getNumber();
System.out.printf("取出的数据是：%d\n", res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
default:
break;
}
}
System.out.println("程序退出~~~");
}
}
//使用数组模拟队列
class CircleArray {
private int maxSize; //队列的最大容量
private int front; //队列的头部
private int rear; //队列的尾部
private int[] arr; //数组用于存放数据，模拟队列
//创建队列的构造器
public CircleArray(int arrMaxSize) {
maxSize = arrMaxSize;
arr = new int[maxSize];
front = 0; // 指向队列数据头部
rear = 0; // 指向队列数据尾部的后一个元素
}
//判断队列是否满了
public boolean isFull() {
// 环形队列的rear与front的关系
return (rear + 1) % maxSize == front;
}
//队列是否为空
public boolean isEmpty() {
return rear == front;
}
//添加数据
public void addQueue(int n) {
while (isFull()) {
System.out.println("队列已满，不能加入数据");
return;
}
//直接将数据加入
arr[rear] = n;
//将rear后移,这里的向后移不是简单的加1。用上图可以推导
rear = (rear + 1) % maxSize;
}
//取出数据
public int getNumber() {
while (isEmpty()) {
throw new RuntimeException("队列为空,不能取数据");
}
//front指向队列的第一个元素
//1.先把front中的值保存到一个临时的变量 ，
int value = arr[front];
//将front后移
front = (front + 1) % maxSize;
//将临时保存的变量返回
return value;
}
//获取头部数据
public int HeadQueue() {
if (isEmpty()) {
throw new RuntimeException("队列为空，没有数据");
}
return arr[front];//循环队列的front就是指向队列的头部
}
public void showQueue() {
if (isEmpty()) {
System.out.println("队列为空，没有数据");
}
//从front开始遍历，遍历的个数为队列中的有效数字
//size（）为队列数据的有效长度，front为有效数据的头
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 - front + maxSize) % maxSize;
}
}
527
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
