Java数据结构和算法(一)之稀疏数组和队列

最新推荐文章于 2024-07-25 16:56:56 发布

Alvis 一昂

最新推荐文章于 2024-07-25 16:56:56 发布

阅读量219

点赞数

分类专栏： Java 文章标签：数据结构算法 java

本文链接：https://blog.csdn.net/weixin_44916936/article/details/125008157

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、几个经典面试题

1.1 字符串匹配问题

判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1

暴力匹配
KMP算法《部分匹配表》

1.2 汉诺塔游戏

将A塔的所有圆盘移动到C塔
小圆盘上不能放大圆盘
在三根柱子之间一次只能移动一个圆盘

分治算法

1.3 八皇后问题

在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。【92】

回溯算法

1.4 马踏棋盘算法（骑士周游问题）

将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格

图的深度优化遍历算法(DFS)
贪心算法优化

二、数据结构和算法概述

程序 = 数据结构 + 算法

2.1 几个实际问题

2.1.1 字符串替换问题

试写出用单链表表示的字符串类及字符串结点类的定义，并依次实现它的构造函数、以及计算串长度、串赋值、判断两串相等、求子串、两串连接、求子串在串中位置等7个成员函数。

public static void main(String[] args) {
	String str = "Java,Java, hello,world!";
	String newStr = str.replaceAll("Java", "算法~"); //算法
	System.out.println("newStr=" + newStr);
}

2.1.2 一个五子棋程序

如何判断游戏的输赢，并可以完成存盘退出和继续上局的功能.

棋盘->二维数组=>(稀疏数组)-> 写入文件【存档功能】

读取文件-》稀疏数组-》二维数组 -》棋盘【接上局】

2.1.3 约瑟夫问题（丢手帕问题）

设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

提示：用一个不带头结点的循环链表来处理Josephu 问题：先构成一个有n个结点的单循环链表（单向环形链表），然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。

2.2 线性结构和非线性结构

2.2.1 线性结构

线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的
链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息
线性结构常见的有：数组、队列、链表和栈

2.2.2 非线性结构

二维数组
多维数组
广义表
树结构
图结构

三、稀疏数组和队列

3.1 稀疏数组

解决需求：编写的五子棋程序中，有存盘退出和续上盘的功能

3.1.1 介绍

当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是:

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

3.1.2 二维数组转稀疏数组

遍历原始的二维数组，得到有效数据的个数sum
根据sum就可以创建稀疏数组sparseArr int[sum+1][3]
将二维数组的有效数据存入到稀疏数组

3.1.3 稀疏数组转二维数组

先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
再读取稀疏数组后几行的数据，并赋值给原始的二维数组

3.1.4 代码实现

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

		//输出原始二维数组
		System.out.println("原始的二维数组");
		for (int[] row:chessArr1){
			for (int data:row){
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}

		//1.将二维数组转稀疏数组
		//1.1 先遍历二维数组，得到非0数据个数
		int sum = 0;
		for (int i=0;i<11;i++){
			for (int j=0;j<11;j++){
				if(chessArr1[i][j]!=0){
					sum++;
				}
			}
		}
		
		//1.2 创建对应的稀疏数组
		int sparseArr[][] = new int[sum+1][3];
		
		//1.3 给稀疏数组赋值
		sparseArr[0][0] = 11;
		sparseArr[0][1] = 11;
		sparseArr[0][2] = sum;

		//1.4 遍历二维数组，将非0的值存放到sparseArr中
		int count = 0;//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();
		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();

		//2.稀疏数组转二维数组
		//2.1 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
		int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
		
		//2.2 再读取稀疏数组后几行的数据，并赋值给原始的二维数组
		for (int i=1;i<sparseArr.length;i++){
			chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
		}
		
		//输出恢复后的二维数组
		System.out.println();
		System.out.println("恢复后的二维数组为：");
		for (int[] row:chessArr2){
			for (int data:row){
				System.out.printf("%d\t",data);
			}
		}
		System.out.println();
	}
}

3.2 队列

使用场景：银行排队案例

3.2.1 队列介绍

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

3.2.2 数组模拟队列

当我们将数据存入队列时称为”addQueue”
将尾指针往后移：rear+1 , 当front == rear 【空】
若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear所指的数组元素中，否则无法存入数据。 rear == maxSize - 1[队列满]
rear 是队列最后[含]
front 是队列最前元素[不含]

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){
		//判断队列是否满
		if(isFull()){
			System.out.println("队列满，不能添加数据！");
			return;
		}
		rear++;
		arr[rear] = n;
	}

	//获取队列的数据，出队列
	public int getQueue(){
		//判断队列是否为空
		if(isEmpty()){
			//通过抛出异常
			throw new RuntimeException("队列空，不能取数据！");
		}
		front++;
		return arr[front];
	}

	//显示队列的所有数据
	public void showQueue(){
		if(isEmpty()){
			System.out.println("队列空的，没有数据！");
			return;
		}
		for(int i=0;i<arr.length;i++){
			System.out.println("arr[%d]=%d\n",i,arr[i]);
		}
	}

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

}

存在问题：取出数据之后，之前的数组空间就不能使用了，没有达到复用的效果。

3.2.3 数组模拟环形队列

对前面的数组模拟队列的优化，充分利用数组。因此将数组看做是一个环形的。(通过取模的方式来实现即可)

front变量的含义调整：front指向队列的第一个元素，也就是arr[front]就是队列的第一个元素，front的初始值=0；
rear变量的含义调整：rear指向队列的最后一个元素的后一个位置。因为希望空出一个空间作为约定。rear的初始值=0；
尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定,这个在做判断队列满的时候需要注意 (rear + 1) % maxSize == front[满]
rear == front [空]
队列中有效的数据的个数：(rear+maxSize-front)%maxSize

class CircleQueue {
	private int maxSize;
	private int[] arr; // 该数组存放数据，模拟队列
	private int front; // 指向队列头部（初始为0）
	private int rear; // 指向队列的尾部（初始为0）

	public CircleArrayQueue(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 + 1) % maxSize;
	}

	public int getQueue() {
		if (isEmpty()) {
			throw new RuntimeException("队列空~");
		}
		int value = arr[front];
		front = (front + 1) % maxSize;
		return value;
	}
	
	//计算队列有多少个元素
	public int size()  {
		return (rear + maxSize - front) % maxSize;
	}

	//显示队列的所有数据
	public void showQueue(){
		if(isEmpty()){
			System.out.println("队列空的，没有数据！");
			return;
		}
		for(int i=0;i<front+size();i++){
			System.out.println("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);
		}
	}

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

Alvis 一昂

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java数据结构和算法(一)之稀疏数组和队列

文章目录一、几个经典面试题1.1 字符串匹配问题1.2 汉诺塔游戏1.3 八皇后问题1.4 马踏棋盘算法（骑士周游问题）二、数据结构和算法概述2.1 几个实际问题2.1.1 字符串替换问题2.1.2 一个五子棋程序2.1.3 约瑟夫问题（丢手帕问题）2.2 线性结构和非线性结构2.2.1 线性结构2.2.2 非线性结构三、稀疏数组和队列3.1 稀疏数组3.1.1 介绍3.1.2 二维数组转稀疏数组3.1.3 稀疏数组转二维数组3.1.4 代码实现3.2 队列3.2.1 队列介绍3.2.2 数组模拟队列3.
复制链接

扫一扫