java实现栈及队列

使用数组实现栈及循环队列。

栈：后进先出

队列：先进先出

1.java实现栈的代码如下所示：

public class MyStack {
    private int maxSize;     //栈中保存的最大元素数
    private int[] stackArray; //数组：用于保存栈中的元素
    private int top;  //栈顶元素位置
    public MyStack(int s){
    maxSize=s;
    stackArray=new int[maxSize];
    top=-1;
    }
    public void push(int j){
    stackArray[++top]=j;
    }
    public int pop(){

    return stackArray[top--];

    }
    public int peek(){
    return stackArray[top];
    }
    public boolean isFull(){
    return top==maxSize-1;
    }

}

由于队列存在假溢出的问题，使用循环队列，可以用于解决此问题。

1. front指向队头，rear指向队尾的下一个位置。初始状态front=rear=0

2. 出队时，front=(front+1)%MAXSIZE；入队时，rear=(rear+1)%MAXSIZE。

3. 队为空的判断：front==rear；队为满的判断：(rear+1)%MAXSIZE==front。

4.队列中的元素数：（rear-front+MAXSIZE）%MAXSIZE。

循环队列实现代码如下所示：

package dataStructure;


public class MyCircleQueue<E>{
    private E[] a;
    private static final int DEFAULT_SIZE=10;
    private int front;
    private int rear;
    private int length;
public MyCircleQueue() {
super();
}
    public MyCircleQueue(int size){
    a=(E[])new Object[size];
    length=0;
    front=0;
    rear=0;
    }
    public boolean enqueue(E obj){
    if(isFull())
    return false;
    a[rear]=obj;
    rear=(rear+1)%length();
    return true;
    }
    public E dequeue(){
    if(isEmpty())
    return null;
    E data=a[front];
    front=(front+1)%a.length;
    return data;
    }
    public int size(){
        return (rear-front+length)%length;
    }
    public int length(){
    return length;
    }
    public boolean isEmpty(){
    if(front==rear)
    return true;
    return false;
    }
    public boolean isFull(){
    if((rear+1)%a.length==front)
    return true;
    return false;
    }
}