java 栈 先进先出_Java三种方式实现栈和队列

栈:LIFO(后进先出)

队列:FIFO(先进先出)

1、栈:LIFO(后进先出)

1.1、栈的顺序存储结构实现:

/**

* 基于数组实现的顺序栈

* @param

*/

public class Stack {

private Object[] data = null;

private int maxSize=0; //栈容量

private int top =-1; //栈顶指针

/**

* 构造函数:根据给定的size初始化栈

*/

Stack(){

this(10); //默认栈大小为10

}

Stack(int initialSize){

if(initialSize >=0){

this.maxSize = initialSize;

data = new Object[initialSize];

top = -1;

}else{

throw new RuntimeException("初始化大小不能小于0:" + initialSize);

}

}

//判空

public boolean empty(){

return top==-1 ? true : false;

}

//进栈,第一个元素top=0;

public boolean push(E e){

if(top == maxSize -1){

throw new RuntimeException("栈已满,无法将元素入栈!");

}else{

data[++top]=e;

return true;

}

}

//查看栈顶元素但不移除

public E peek(){

if(top == -1){

throw new RuntimeException("栈为空!");

}else{

return (E)data[top];

}

}

//弹出栈顶元素

public E pop(){

if(top == -1){

throw new RuntimeException("栈为空!");

}else{

return (E)data[top--];

}

}

//返回对象在堆栈中的位置,以 1 为基数

public int search(E e){

int i=top;

while(top != -1){

if(peek() != e){

top --;

}else{

break;

}

}

int result = top+1;

top = i;

return result;

}

}

1.2、栈的链式存储结构实现:

public class LinkStack {

//链栈的节点

private class Node{

E e;

Node next;

public Node(){}

public Node(E e, Node next){

this.e = e;

this.next = next;

}

}

private Node top; //栈顶元素

private int size; //当前栈大小

public LinkStack(){

top = null;

}

//当前栈大小

public int length(){

return size;

}

//判空

public boolean empty(){

return size==0;

}

//入栈:让top指向新创建的元素,新元素的next引用指向原来的栈顶元素

public boolean push(E e){

top = new Node(e,top);

size ++;

return true;

}

//查看栈顶元素但不删除

public Node peek(){

if(empty()){

throw new RuntimeException("空栈异常!");

}else{

return top;

}

}

//出栈

public Node pop(){

if(empty()){

throw new RuntimeException("空栈异常!");

}else{

Node value = top; //得到栈顶元素

top = top.next; //让top引用指向原栈顶元素的下一个元素

value.next = null; //释放原栈顶元素的next引用

size --;

return value;

}

}

}

1.3、基于LinkedList实现的栈结构:

import java.util.LinkedList;

/**

* 基于LinkedList实现栈

* 在LinkedList实力中只选择部分基于栈实现的接口

*/

public class StackList {

private LinkedList ll = new LinkedList();

//入栈

public void push(E e){

ll.addFirst(e);

}

//查看栈顶元素但不移除

public E peek(){

return ll.getFirst();

}

//出栈

public E pop(){

return ll.removeFirst();

}

//判空

public boolean empty(){

return ll.isEmpty();

}

//打印栈元素

public String toString(){

return ll.toString();

}

}

2、队列:FIFO(先进先出)

2.1 队列的顺序存储结构实现

public class Queue {

private Object[] data=null;

private int maxSize; //队列容量

private int front; //队列头,允许删除

private int rear; //队列尾,允许插入

//构造函数

public Queue(){

this(10);

}

public Queue(int initialSize){

if(initialSize >=0){

this.maxSize = initialSize;

data = new Object[initialSize];

front = rear =0;

}else{

throw new RuntimeException("初始化大小不能小于0:" + initialSize);

}

}

//判空

public boolean empty(){

return rear==front?true:false;

}

//插入

public boolean add(E e){

if(rear== maxSize){

throw new RuntimeException("队列已满,无法插入新的元素!");

}else{

data[rear++]=e;

return true;

}

}

//返回队首元素,但不删除

public E peek(){

if(empty()){

throw new RuntimeException("空队列异常!");

}else{

return (E) data[front];

}

}

//出队

public E poll(){

if(empty()){

throw new RuntimeException("空队列异常!");

}else{

E value = (E) data[front]; //保留队列的front端的元素的值

data[front++] = null; //释放队列的front端的元素

return value;

}

}

//队列长度

public int length(){

return rear-front;

}

}

2.2、循环队列的顺序存储结构实现

import java.util.Arrays;

public class LoopQueue {

public Object[] data = null;

private int maxSize; // 队列容量

private int rear;// 队列尾,允许插入

private int front;// 队列头,允许删除

private int size=0; //队列当前长度

public LoopQueue() {

this(10);

}

public LoopQueue(int initialSize) {

if (initialSize >= 0) {

this.maxSize = initialSize;

data = new Object[initialSize];

front = rear = 0;

} else {

throw new RuntimeException("初始化大小不能小于0:" + initialSize);

}

}

// 判空

public boolean empty() {

return size == 0;

}

// 插入

public boolean add(E e) {

if (size == maxSize) {

throw new RuntimeException("队列已满,无法插入新的元素!");

} else {

data[rear] = e;

rear = (rear + 1)%maxSize;

size ++;

return true;

}

}

// 返回队首元素,但不删除

public E peek() {

if (empty()) {

throw new RuntimeException("空队列异常!");

} else {

return (E) data[front];

}

}

// 出队

public E poll() {

if (empty()) {

throw new RuntimeException("空队列异常!");

} else {

E value = (E) data[front]; // 保留队列的front端的元素的值

data[front] = null; // 释放队列的front端的元素

front = (front+1)%maxSize; //队首指针加1

size--;

return value;

}

}

// 队列长度

public int length() {

return size;

}

//清空循环队列

public void clear(){

Arrays.fill(data, null);

size = 0;

front = 0;

rear = 0;

}

}

2.3、队列的链式存储结构实现

public class LinkQueue {

// 链栈的节点

private class Node {

E e;

Node next;

public Node() {

}

public Node(E e, Node next) {

this.e = e;

this.next = next;

}

}

private Node front;// 队列头,允许删除

private Node rear;// 队列尾,允许插入

private int size; //队列当前长度

public LinkQueue() {

front = null;

rear = null;

}

//判空

public boolean empty(){

return size==0;

}

//插入

public boolean add(E e){

if(empty()){ //如果队列为空

front = new Node(e,null);//只有一个节点,front、rear都指向该节点

rear = front;

}else{

Node newNode = new Node(e, null);

rear.next = newNode; //让尾节点的next指向新增的节点

rear = newNode; //以新节点作为新的尾节点

}

size ++;

return true;

}

//返回队首元素,但不删除

public Node peek(){

if(empty()){

throw new RuntimeException("空队列异常!");

}else{

return front;

}

}

//出队

public Node poll(){

if(empty()){

throw new RuntimeException("空队列异常!");

}else{

Node value = front; //得到队列头元素

front = front.next;//让front引用指向原队列头元素的下一个元素

value.next = null; //释放原队列头元素的next引用

size --;

return value;

}

}

//队列长度

public int length(){

return size;

}

}

2.4、基于LinkedList实现队列结构

/**

* 使用java.util.Queue接口,其底层关联到一个LinkedList(双端队列)实例.

*/

import java.util.LinkedList;

import java.util.Queue;

public class QueueList {

private Queue queue = new LinkedList();

// 将指定的元素插入此队列(如果立即可行且不会违反容量限制),在成功时返回 true,

//如果当前没有可用的空间,则抛出 IllegalStateException。

public boolean add(E e){

return queue.add(e);

}

//获取,但是不移除此队列的头。

public E element(){

return queue.element();

}

//将指定的元素插入此队列(如果立即可行且不会违反容量限制),当使用有容量限制的队列时,

//此方法通常要优于 add(E),后者可能无法插入元素,而只是抛出一个异常。

public boolean offer(E e){

return queue.offer(e);

}

//获取但不移除此队列的头;如果此队列为空,则返回 null

public E peek(){

return queue.peek();

}

//获取并移除此队列的头,如果此队列为空,则返回 null

public E poll(){

return queue.poll();

}

//获取并移除此队列的头

public E remove(){

return queue.remove();

}

//判空

public boolean empty() {

return queue.isEmpty();

}

}

  • 1
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值