Java基础：栈、队列

目录

前言

介绍

---

前言

复习基础，做个笔记

介绍

栈

可以把栈看成一个盒子

往盒子里放的操作叫进栈

从盒子里取的操作叫出栈

盒子的顶部叫栈顶

盒子的底部叫栈底

栈的特点

先进后出 LIFO（Last In First Out），如果想要拿到盒子底下的东西，得把盒子上面的东西先移走

栈的分类有两种

• 静态栈
• 动态栈

基于简单数组实现方式

public class Stack {
    //栈的大小
    private int size;
    //栈顶元素的下标
    private int top;
    //栈的容器
    private char[] stackArray;

    public Stack(int size){
        stackArray = new char[size];
        top = -1;//初始化的时候由于栈内没有元素，将栈顶下标设置为-1
        this.size = size;
    }
    //人栈 栈顶的下标+1
    public void push(char item){
        stackArray[++top] = item;
    }
    //出栈，删除栈顶元素，栈顶元素的下标-1
    public int pop(){
        return stackArray[top--];
    }
    //查看栈顶元素，不删除
    public char find(){
        return stackArray[top];
    }
    //判空
    public boolean isEmpty(){
        return (top == -1);
    }
    //判满
    public boolean isFull(){
        return (top == size - 1);
    }

    public static void main(String[] args){
        Stack stack = new Stack(5);
        stack.push('a');
        stack.push('b');
        stack.push('c');
        stack.push('d');
        char ch = stack.find();
        System.out.println(ch);
    }
}

打印结果显示d，符合后进先出规则，d元素为栈顶

基于动态数组实现方式

public class Stack {
    public int size;//栈的大小
    public int top;//栈顶元素的下标
    public static char[] stackArray;//栈的容器
    public Stack(int size){
        stackArray = new char[size];
        top = -1;          //初始化栈的时候由于栈内没有元素，栈顶下标设为-1
        this.size = size;
    }
    //入栈,栈顶的下标+1
    public void push(char item){
        if(isFull()){
            doubleStack();
        }
        stackArray[++top] = item;
    }
    //模拟数组的扩容
    public void doubleStack(){
        char[] newStackArray = new char[size*2];
        for(int i = 0;i<size;i++){
            newStackArray[i] = stackArray[i];
        }
        size = size*2;
        stackArray = newStackArray;
    }
    //出栈，删除栈顶元素，栈顶元素的下标-1
    public int pop(){
        if(isEmpty()){
            System.out.println("Stack is Empty");
            return 0;
        }else{
            return stackArray[top--];
        }
    }
    //查看栈顶元素，不删除
    public char find(){
        return stackArray[top];
    }
    //判空
    public boolean isEmpty(){
        return (top == -1);
    }
    //判满
    public boolean isFull(){
        return (top == size - 1);
    }
    public static void main(String[] args){
        Stack stack = new Stack(5);
        stack.push('a');
        stack.push('b');
        stack.push('c');
        stack.push('d');
        stack.push('e');
        stack.push('f');
        stack.push('g');
        stack.push('h');//一共8个元素
        char ch = stack.find();
        System.out.println(ch);
        System.out.println(stackArray.length);
    }
}

 

打印结果 

队列

特点

先进先出 FIFO（First In First Out），进出顺序一致

需要注意的是：有时候在数据结构中还有可能按照大小排队或者按照一定条件排队的数据队列，这时的队列处于特殊队列，不一定按照先进先出的规则读取数据了

队列的实现方式

• 通过数组实现一个队列
• 通过集合实现一个队列
• 通过两个堆栈实现

基于简单数组实现

public class Queue {

    private String[] arr; //队列数组
    private static int end = 0; //队尾标志

    public static void push(String[] arr, String value) {
        if (end < arr.length) {
            arr[end] = value;
            end++;
            return;
        } else {
            System.out.println("队列已满");
            return;
        }
    }
    //取出队列元素
    public static String pop(String[] arr) {
        String res;
        if (arr[0] == null) {
            System.out.println("队列为空");
            return null;
        } else {
            res = arr[0];
            arr[0] = null;
            move(arr);
            return res;
        }
    }

    //队列元素向前移动
    public static void move(String[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i + 1] != null) {
                arr[i] = arr[i + 1];
            } else {
                arr[i] = null;
                break;
            }
        }
    }
    public static void main(String[] args) {
        //初始化队列大小
        String [] arr = new String[10];
        push(arr,"北京");
        push(arr,"上海");
        push(arr,"广州");
        push(arr,"深圳");
        push(arr,"杭州");
        push(arr,"成都1");
        push(arr,"成都2");
        push(arr,"成都3");
        push(arr,"成都4");
        push(arr,"成都5");
        push(arr,"成都6");

        System.out.println("队列大小"+arr.length);
        System.out.println(end);

        System.out.println(pop(arr));
        System.out.println(pop(arr));
        System.out.println(pop(arr));
        System.out.println(pop(arr));

    }

}

 

打印结果