栈和队列的复习

栈和队列

本章通过实例引入了栈和队列的概念，栈“后进先出” （低端封死，上段开），队列“先进先出”（低端可打开）。

 

*栈和队列的顺序存储结构、链式存储结构

*特点和相应算法的实现

 

定义：

栈是一种特殊的线性表，其全部操作被限制在表的一端固定进行，而且构成栈的元素，必须是同一种数据类型。

 

概念：

栈的特点是在线性表的固定端（top端）进行操作，即出栈和入栈，另一端可以理解为封死了的固定端（bottom）。

 

4.2栈的操作过程

栈是特殊的线性表，因此其存储结构和线性表相似，可以分为顺序存储和链式存储。

 

1.顺序栈

将栈在顺序存储结构下所得的结构，成为顺序栈。顺序栈类似于高级语言中的数组，

因此可以使用数组实现顺序栈的相关运算。

public class StackX{//定义栈
    private final int SIZE=20;
    private int[] st;//??？
    private int top;
    public StackX(){//构造方法
        st=new int[SIZE];
        top=-1;//空栈
    }
    public void push(int j){//压栈
        st[++top]=j;
    }
    public int pop(){//出栈
        return st[top--];//??
    }
    public int peek(){
        return st[top];//??peek是什么意思？？
    }
    public boolean isEmpty(){//空栈
        return (top==-1);
    }
}

在java中可以通过类的对象引用实现指针的运算。//??

public class MyStack{
    //底层实现是一个数组
    private long[] arr;
    private int top;

    //默认构造函数
    public MyStack(){
        arr=new long[10];//
        top=-1;
    }

    //带参数构造函数方法，参数为数组初始化大小
    public MyStack(int maxsize){
        arr=new long[maxsize];
        top=-1;
    }

    //添加数据
    public void push(int value){
      arr[++top]=value;
    }

    //移除数据
    public long pop(){
        return arr[top--];
    }

    //查看数组
    public long peek(){
        return arr[top];
    }

    //判断是否为空
    public boolean isEmpty(){
         return top==-1;//
    }

    //判断是否为满
    public boolean isFull(){
        return top==arr.length-1;//因为从0开始
    }
}

public class TestMystack{
    public static void main(String[] args) {
        MyStack ms=new MyStack(4);
        ms.push(23);
        ms.push(12);
        ms.push(1);
        ms.push(90);
        System.out.println(ms.isEmpty());
        System.out.println(ms.isFull());
        System.out.println(ms.peek());
        while (!ms.isEmpty()) {
            System.out.println(ms.pop()+",");
        }

    }
}

队列

队列相当于水管，先进先出。

public class MyQueue{
    //底层使用数组
    private long[] arr;
    //有效数据的大小
    private int elements;
    //对头
    private int front;
    //队尾
    private int end;

    //默认构造函数
    public MyQueue(){
        arr=new long[10];//这里长度是10，可是后面为什么是4？
        elements=0;
        front=0;
        end=-1;
    }
    
    //添加数据，从队尾插入
    public void insert(long value){
        arr[++end]=value;
        elements++;
    }
    //删除数据，从队头删除
    public void remove(){
        elements--;
        return arr[front--];
    }
    //查看数据，从队头
    public long peek(){
        return arr[front];
    }
    //判断是否为空
    public boolean isEmpty(){
        return elements==0;
    }
    //判断是否满了
    public boolean isFull(){
        return elements==arr.length;
    }


}
public class TestMyQueue{
    public static void main(String[] args) {
           MyQueue mq=new MyQueue(4);
           mq.insert(23);
           mq.insert(45);
           mq.insert(13);
           mq.insert(1);
           System.out.println(mq.isFull());
           System.out.println(mq.isEmpty());
           System.out.println(mq.peek());
           while(!mq.isEmpty()){
           System.out.println(mq.remove()+" ");
           }
    }
//把while复习一下
}

//如果队列满了，就把元素放到队头，当然此时该数组必须是循环数组。

//还有为什么会运行出错？

//队列删除是从队的队头，而插入是从队尾。