1.编写程序,使用一维数组,模拟栈数据结构
| 要求 |
|---|
| 1.栈内可以存放任意数据 |
| 2.栈内提供push方法模拟压栈 |
| 3.栈内提供pop方法模拟出栈 |
| 4.栈的大小默认为10 |
新建MyStack类
/**
* @author DeYou
* @date 2022/11/10 23:01
*/
public class MyStack {
Object[] element;
int index;
public MyStack(){
element=new Object[10];
index=-1;
}
/**
* @param object 被压入的元素
*/
public void push(Object object){
if (index>=element.length-1){
System.out.println(object+"压栈失败,栈已满");
}else {
index++;//当index为9的时候,再自加1为10,超过了数组索引的最大值,所以上面的判断条件为大于等于9
element[index]=object;
System.out.print(element[index]+"压栈成功\t");
if (index==4){//为了方便截图每行五个后换行
System.out.println();
}
}
}
/**
*
* @return 弹出的元素
*/
public void pop(){
if (index<0){
System.out.println("栈已空");
}else{
System.out.print(index+":"+element[index]+"弹出\t");
index--;
}
}
public Object[] getElement() {
return element;
}
public void setElement(Object[] element) {
this.element = element;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}
创建MyStackTest测试类
public class MyStackTest {
public static void main(String[] args) {
MyStack myStack=new MyStack();
for (int i = 0; i < 11; i++) {
myStack.push(new String("123"));
}
for (int i = 0; i < 11; i++) {
myStack.pop();
}
}
}
栈的特点:先进后出
借助index栈帧指向栈顶,index初始值为-1,通过index自增(++)和自减(–)来进行数据的压栈和弹栈操作,
2.编写程序,为某个酒店编写程序,酒店管理系统,模拟订房和退房,并打印所有的房间状态功能
1.该系统的用户是:酒店前台
2.所有的房间使用一个二维数组来模拟
3.酒店的每个房间是一个java对象:Room
4.每个房间都有:编号,类型,是否空
新建Room类(房间类)
public class Room {
/**
* @param number 房间号 type 类型 state 是否入住
*/
private int number;
private String type;
private boolean state;
public Room() {
}
public Room(int number, String type, boolean state) {
this.number = number;
this.type = type;
this.state = state;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public boolean getState() {
return state;
}
public void setState(boolean state) {
this.state = state;
}
@Override
public String toString() {
return "房间号:" + number +
", 类型:" + type +
", 是否入住:" + state+"\t";
}
}
创建酒店类(HotelManagementSystem)
import java.util.Arrays;
public class HotelManagementSystem {
private Room[][] rooms;
/**
* 初始化酒店并设置房间的数量和默认状态
*/
public HotelManagementSystem(){
rooms=new Room[4][4];
for (int i = 0; i < rooms.length; i++) {
for (int j = 0; j < rooms[i].length; j++) {
rooms[i][j]=new Room();
switch (i){
case 0:rooms[i][j].setType("双人间");break;
case 1:rooms[i][j].setType("单人间");break;
case 2:rooms[i][j].setType("豪华间");break;
case 3:rooms[i][j].setType("至尊间");break;
}
rooms[i][j].setState(false);
rooms[i][j].setNumber((i+1)*100+j+1);
}
}
}
/**
* 订房
* @param nmber 房间编号
* @return
*/
public boolean addState(int nmber){
if(!rooms[nmber/100-1][nmber%100-1].getState()){
rooms[nmber/100-1][nmber%100-1].setState(true);
System.out.println("订房成功");
return true;
};
return false;
}
/**
* 退房
* @param nmber 房间编号
* @return
*/
public boolean delectState(int nmber){
if(rooms[nmber/100-1][nmber%100-1].getState()){
rooms[nmber/100-1][nmber%100-1].setState(false);
System.out.println("退房成功");
return true;
};
return false;
}
/**
* 查询所有的房间
*/
public void selectRoom(){
for (Room[] s: rooms) {
for (Room r: s) {
if (!r.getState()){
System.out.print(r);
}
}
System.out.println();
}
}
public Room[][] getRooms() {
return rooms;
}
public void setRooms(Room[][] rooms) {
this.rooms= rooms;
}
@Override
public String toString() {
return "HotelManagementSystem{" +
"rooms=" + Arrays.toString(rooms) +
'}';
}
}
创建酒店测试类(otelManagementSystemTest)
public class HotelManagementSystemTest {
public static void main(String[] args) {
HotelManagementSystem hotelManagementSystem = new HotelManagementSystem();
//入住101房间
hotelManagementSystem.addState(101);
//退房101房间
hotelManagementSystem.delectState(101);
//入住101房间
hotelManagementSystem.addState(101);
//入住102房间
hotelManagementSystem.addState(102);
//入住103房间
hotelManagementSystem.addState(201);
System.out.println("未入住房间有");
//查询所有
hotelManagementSystem.selectRoom();
//获取酒店所有的房间
Room[][] room=hotelManagementSystem.getRooms();
System.out.println("======================");
//打印所有的房间
for (Room[] r: room) {
for (Room i:r) {
System.out.print(i);
}
System.out.println();
}
}
}
3.编写程序,模拟队列数据结构
一些条件:
- 队列先进先出
- 有队头队尾两个属性
- 有出队和入队操作(入队在队尾操作,出队在队头操作)
- 默认队列大小为10
创建myqueue类(队列类)
public class MyQueue {
/**
* front 队头
* rear 队尾
*/
private int[] arrays;
private int front;
private int rear;
public MyQueue(){
arrays=new int[10];
front=0;
rear=0;
}
/**
*
* @param number 入队元素
* @return 是否入队成功
*/
public boolean enQueue(Integer number){
//arrays.length==rear 判断队满
if (!(arrays.length==rear)){
arrays[rear]=number;
rear++;
return true;
}else {
return false;
}
}
/**
* 出队
* @return 返回出队的元素
*/
public Integer deQueen(){
//队列空无法完成出队操作
if (!(front==arrays.length||front==rear)){
front++;
return arrays[front-1];
}else {
return null;
}
}
}
假溢出的现象:arrays.length==rear这是上面判断队满的条件,但实际上还有三个空间没有使用
上述图也满足队满的条件,但并没有队满,所以出现了循环队列,避免了浪费空间
循环队列:将顺序队列臆造成一个环状的空间,即把存储队列元素的顺序队列从逻辑上视为一个环
队列会存在假溢出为了避免这一问题出现了循环队列
循环队列如下图
上述判断队满的方式为:舍弃一个空间来区别队满和队空
循环队列条件如下:
- 队满:(rear+1)%queue.length==front
- 队空:front==rear
另外两种为
- 设置状态字段:增加数据成员,例如tag=0时,若因删除导致front==rear则为队空,tag=1,若因添加导致front=rear则为队满
- 添加表示数据元素的个数,当实际存放的数据大小等于空间大小则为队满
一次简单的关于java数组使用的小实践 ! ! !
如有错误,请麻烦留言,我会及时改之,以防给别人带来错误的观点
![[附源码]计算机毕业设计血库管理系统Springboot程序](https://img-blog.csdnimg.cn/3c2b6b638b034253b52427ea7f3b5c9a.png)
