Java实现栈和队列
栈：LIFO（后进先出）
队列：FIFO（先进先出）
栈的顺序存储结构实现：
/** * 基于数组实现的顺序栈 * @param <E> */ public class Stack<E> { 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; } }
栈的链式存储结构实现：
public class LinkStack<E> { //链栈的节点 private class Node<E>{ E e; Node<E> next; public Node(){} public Node(E e, Node next){ this.e = e; this.next = next; } } private Node<E> 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<E> peek(){ if(empty()){ throw new RuntimeException("空栈异常！"); }else{ return top; } } //出栈 public Node<E> pop(){ if(empty()){ throw new RuntimeException("空栈异常！"); }else{ Node<E> value = top; //得到栈顶元素 top = top.next; //让top引用指向原栈顶元素的下一个元素 value.next = null; //释放原栈顶元素的next引用 size --; return value; } } }
基于LinkedList实现的栈结构：
import java.util.LinkedList; /** * 基于LinkedList实现栈 * 在LinkedList实力中只选择部分基于栈实现的接口 */ public class StackList<E> { private LinkedList<E> ll = new LinkedList<E>(); //入栈 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(); } }
队列的顺序存储结构实现
public class Queue<E> { 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; } }
循环队列的顺序存储结构实现
import java.util.Arrays; public class LoopQueue<E> { 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; } }
队列的链式存储结构实现
public class LinkQueue<E> { // 链栈的节点 private class Node<E> { E e; Node<E> 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<E> newNode = new Node<E>(e, null); rear.next = newNode; //让尾节点的next指向新增的节点 rear = newNode; //以新节点作为新的尾节点 } size ++; return true; } //返回队首元素，但不删除 public Node<E> peek(){ if(empty()){ throw new RuntimeException("空队列异常！"); }else{ return front; } } //出队 public Node<E> poll(){ if(empty()){ throw new RuntimeException("空队列异常！"); }else{ Node<E> value = front; //得到队列头元素 front = front.next;//让front引用指向原队列头元素的下一个元素 value.next = null; //释放原队列头元素的next引用 size --; return value; } } //队列长度 public int length(){ return size; } }
基于LinkedList实现队列结构
/** * 使用java.util.Queue接口,其底层关联到一个LinkedList（双端队列）实例. */ import java.util.LinkedList; import java.util.Queue; public class QueueList<E> { private Queue<E> queue = new LinkedList<E>(); // 将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 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(); } }
