java数组应用(栈和队列以及酒店模拟)

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数组使用的小实践 ! ! !
如有错误,请麻烦留言,我会及时改之,以防给别人带来错误的观点