《栈 队列》——栈与队列（Java）

一：对列

package Queue;

/*
* 使用java构建队列，并模拟实现队列的入队和出对方法
*/

public class Queue {     //队列类

private int maxSize;  //定义队列的长度
private int[] arrQueue;      //队列
private int rear;     //定义队列的尾指针
private int front;   //定义队列的头指针
private int empty;  //元素的个数

public Queue(int s)   //初始化构造函数
{
maxSize = s;
arrQueue = new int[s];
rear = -1;
front=0;
empty = 0;
}

//实现插入方法
public void insert(int m)
{
if(rear == maxSize-1)   //处理循环
rear = -1;
arrQueue[++rear] = m;   //对尾指针加一，把值放在队列结尾
empty++;      //队列元素个数加1
System.out.println("队列入队元素 为：" + m);
}

//实现出栈的方法，即取得队列的头元素
public int remove()
{
int temp = arrQueue[front++]; //将栈顶元素赋值给temp，栈顶指针加1
if(front == maxSize) //处理循环
front = 0;
empty--; //元素个数-1
return temp;
}

//判断队列是否为空
public boolean isEmpty()
{
return (empty==0);
}

//判断对列是否为满
public boolean isFull()
{
return (empty == maxSize);
}

//返回队列长度
public int qLong()
{
return empty;
}

public static void main(String[] args) {
Queue q = new Queue(5); //初始化队列为5个元素

q.insert(1);
q.insert(2);
q.insert(3);
q.insert(4);
q.insert(5);

int t1 = q.remove();
System.out.println("队列元素出队：" + t1);
int t2 = q.remove();
System.out.println("队列元素出队：" + t2);

System.out.println("队列是否为空：" + q.isEmpty());
System.out.println("队列是否为满：" + q.isFull());
System.out.println("队列的长度：" + q.qLong());
}

}

二：栈

1：使用数组模拟栈

package Statck;
/*
* 使用java构建栈，并模拟实现栈的入栈和出栈方法
* 使用数组实现
*/

public class Statck1 {

private int maxSize;     //栈的最多元素数
private int top;    //栈顶指针
private int len;     //栈的深度
private int[] arrStack; // 模拟栈

//栈的初始化
public Statck1(int s){
maxSize = s;
len =0;
top= -1;
arrStack = new int[s];
}

//获取栈的长度
public int getLen(){
return len;
}

//获取当前栈还能插入多少个f元素
public int getLeaveLen(){
return (maxSize-len);
}
//判断栈是否满
public boolean isFull(){
return (len==maxSize);
}

//判断栈是否为空
public boolean isEmpty(){
return (len ==0);
}

//元素入栈
public void inStack(int s)
{
arrStack[++top] = s; //栈顶指针加1,入栈
System.out.println("元素入栈：" + s);
len ++ ;//栈深度+1
}

//元素出栈
public int outStack()
{
int temp = arrStack[top--];//赋值之后减1
System.out.println("元素出栈：" + temp);
len--;   //栈深度-1
return temp;
}

public static void main(String[] args) {
Statck1 s = new Statck1(5);

s.inStack(1);
s.inStack(2);
s.inStack(3);
s.inStack(4);
s.inStack(5);

s.outStack();
s.outStack();
System.out.println("栈的长度：" + s.getLen());
System.out.println("还能入栈元素个数：" + s.getLeaveLen());
System.out.println("栈的是否为空：" + s.isEmpty());
System.out.println("栈的是否为满：" + s.isFull());
}
}

2：使用链表模拟栈

package Statck;

import java.util.ArrayList;
import java.util.EmptyStackException;
import java.util.List;

/*
* 使用java构建栈，并模拟实现栈的入栈和出栈方法
* 使用链表实现
*/

public class Statck2<E extends Object> {

private List<E> statck = new ArrayList<E>();

public Statck2(){
//栈的初始化
}

//清空栈
public void clear(){
statck.clear();
System.out.println("清空栈..........");
}
//判断栈是否为空
public boolean isEmpty(){
return statck.isEmpty();
}
//获取栈顶元素
public E getTop(){
if(isEmpty())
return null;
return statck.get(0);
}

//弹出栈操作
public E pop(){
if (isEmpty())
throw new EmptyStackException();
System.out.println(statck.size() + "\t 出栈");
return statck.remove(statck.size() - 1);
}

//压入栈操作
public void push(E e){
statck.add(e);
System.out.println(e + "\t 入栈");
}

//获取当前栈的深度
public int getStatckSize(){
if(isEmpty())
throw new EmptyStackException();
return statck.size();
}

public static void main(String[] args) {
Statck2 s = new Statck2();
s.clear();           //清空栈
System.out.println("当前栈是否为空：" + s.isEmpty());
s.push(1);
s.push(2);
s.push(3);

s.pop();
System.out.println("当前栈的深度为：" + s.getStatckSize());
System.out.println("当前栈顶元素为：" + s.getTop());
}

}