一，栈

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;

}

}

测试：

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());

System.out.println(ms.peek());

while(!ms.isEmpty()) {

System.out.print(ms.pop() + ",");

}

System.out.println(ms.isEmpty());

System.out.println(ms.isFull());

}

}

二，队列

public class MyQueue {

//底层使用数组

private long[] arr;

//有效数据的大小

private int elements;

//队头

private int front;

//队尾

private int end;

/**

* 默认构造方法

*/

public MyQueue() {

arr = new long[10];

elements = 0;

front = 0;

end = -1;

}

/**

* 带参数的构造方法，参数为数组的大小

*/

public MyQueue(int maxsize) {

arr = new long[maxsize];

elements = 0;

front = 0;

end = -1;

}

/**

* 添加数据,从队尾插入

*/

public void insert(long value) {

arr[++end] = value;

elements++;

}

/**

* 删除数据，从队头删除

*/

public long 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 MyCycleQueue {

//底层使用数组

private long[] arr;

//有效数据的大小

private int elements;

//队头

private int front;

//队尾

private int end;

/**

* 默认构造方法

*/

public MyCycleQueue() {

arr = new long[10];

elements = 0;

front = 0;

end = -1;

}

/**

* 带参数的构造方法，参数为数组的大小

*/

public MyCycleQueue(int maxsize) {

arr = new long[maxsize];

elements = 0;

front = 0;

end = -1;

}

/**

* 添加数据,从队尾插入

*/

public void insert(long value) {

if(end == arr.length - 1) {

end = -1;

}

arr[++end] = value;

elements++;

}

/**

* 删除数据，从队头删除

*/

public long remove() {

long value = arr[front++];

if(front == arr.length) {

front = 0;

}

elements--;

return value;

}

/**

* 查看数据，从队头查看

*/

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) {

MyCycleQueue mq = new MyCycleQueue(4);

//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());

System.out.println(mq.peek());

while (!mq.isEmpty()) {

System.out.print(mq.remove() + " ");

}

System.out.println();

mq.insert(23);

mq.insert(45);

mq.insert(13);

mq.insert(1);

while (!mq.isEmpty()) {

System.out.print(mq.remove() + " ");

}

}

}