栈和队列
近期开始接触栈和队列相关知识，特此根据现有知识对栈和队列做以小结，以下博客仅作为个人学习过程的小结，如能对各位博友有所帮助不胜荣幸。
本篇博客将简单介绍相关知识，以及其注意事项有哪些，只做本人小结，后期随学习深入再做补充修改。
栈（stack）:
概念
栈是一种特殊的线性表，在结点上的操作受到了限制，即上篇博客所提及的受限线性表。只能固定的从一段插入和删除结点，通俗上将允许进行插入删除操作的一端称为栈顶，想应的另一端称为栈底。将结点插入到栈顶中的操作称为入栈，而将栈顶结点删除的操作称为出栈。
他的特点为，后入先出——
队列（Queue）：
概念
队列同之前的栈一样也是一种受限线性表，其被限制表的前端进行删除，在表的后端进行插入，通俗上将删除端称为队头，将插入端称为队尾。
其特点为,先入先出——
双端队列（Deque）
概念：
双端队列是两端允进行插入删除操作的，它可以实现栈的操作同时也可以实现队列的操作
栈和队列的实现
- 仿写(java.util.impl.Queue)的 Queue 接口
package imp;
import java.util.NoSuchElementException;
//仿写(java.util.impl.Queue)的 Queue 接口
public interface Queue {
//通过返回特殊值来通知错误的一组方法
//插入(true 成功，false 失败)
boolean offer(Integer e);
//查看，返回队首元素，但不删除(返回null为空列表)
Integer peek();
//删除，返回并删除并删除首元素(返回null为空列表)
Integer poll();
//通过抛出异常来通知错误的一组方法
//插入(永远返回true)
default boolean add(Integer e){
if(!offer(e)){
throw new IllegalStateException();
}
return offer(e);
}
//查看，返回队首元素，但不删除
default Integer element(){
if(peek() == null){
throw new NoSuchElementException();
}
return peek();
}
//删除，返回并删除并删除首元素
default Integer remove(){
if(poll() == null){
throw new NoSuchElementException();
}
return poll();
}
}
- 定义一个 Deque 接口让它继承 Queue 接口
package imp;
import java.util.NoSuchElementException;
public interface Deque extends Queue {
//通过返回特殊值来通知错误的一组方法
boolean offerFirst(Integer e);
Integer peekFirst();
Integer pollFirst();
boolean offerLast(Integer e);
Integer peekLast();
Integer pollLast();
//通过抛出异常来通知错误的一组方法
default boolean addFirst(Integer e){
if(!offerFirst(e)){
throw new IllegalStateException();
}
return offerFirst(e);
}
default boolean addLast(Integer e){
if(!offerLast(e)){
throw new IllegalStateException();
}
return offerLast(e);
}
default Integer getFirst(){
if(peekFirst() == null){
throw new NoSuchElementException();
}
return peekFirst();
}
default Integer getLast(){
if(peekLast() == null){
throw new NoSuchElementException();
}
return peekLast();
}
default Integer removeFirst(){
if(pollFirst() == null){
throw new NoSuchElementException();
}
return pollFirst();
}
default Integer removeLast(){
if(pollLast() == null){
throw new NoSuchElementException();
}
return pollLast();
}
//继承自 Queue 的方法
default boolean offer(Integer e){
return offerLast(e);
}
//查看，返回队首元素，但不删除(返回null为空列表)
default Integer peek(){
return getFirst();
}
//删除，返回并删除并删除首元素(返回null为空列表)
default Integer poll(){
return pollFirst();
}
//为 stack 准备的方法
default void push(Integer e){
addFirst(e);
}
default Integer pop(){
return removeFirst();
}
}
- 定义一个 LinkedList 类来实现 Deque 接口
package imp;
public class LinkedList implements Deque{
private static class Node{
private Integer v;
Node previous;
Node next;
Node(Integer e){
v = e;
}
@Override
public String toString() {
return v + " ";
}
}
private Node head;
private Node tail;
private int size;
@Override
public boolean offerFirst(Integer e) {
Node node = new Node(e);
if (size == 0) {
head = node;
tail = node;
}else {
head.previous = node;
node.next = head;
head = node;
}
size++;
return true;
}
@Override
public Integer peekFirst() {
if(head == null){
return null;
}
return head.v;
}
@Override
public Integer pollFirst() {
if(size == 0){
return null;
}
int num = head.v;
head = head.next;
if(head != null){
head.previous = null;
}else{
tail = null;
}
size--;
return num;
}
@Override
public boolean offerLast(Integer e) {
Node node = new Node(e);
if(size == 0){
head = node;
}else{
node.previous = tail;
tail.next = node;
}
tail = node;
size++;
return true;
}
@Override
public Integer peekLast() {
if(tail == null){
return null;
}
return tail.v;
}
@Override
public Integer pollLast() {
if(size == 0){
return null;
}
int num = tail.v;
tail = tail.previous;
if(tail != null){
tail.next = null;
}else{
head = null;
}
size--;
return num;
}
}
- 调试 自行实现的 Stack 和 Queue
package imp;
package imp;
public class MyStack {
public static void main(String[] args) {
Deque myStack = new LinkedList();
myStack.push(1);
System.out.print(myStack.peek()+" ");
myStack.push(2);
System.out.print(myStack.peek()+" ");
myStack.push(3);
System.out.print(myStack.peek()+" ");
myStack.push(4);
System.out.print(myStack.peek()+" ");
myStack.push(5);
System.out.println(myStack.peek()+" ");
myStack.pop();
System.out.println(myStack.peek());
}
}
package imp;
public class MyQueue {
public static void main(String[] args) {
Deque myQueue = new LinkedList();
myQueue.add(1);
System.out.print(myQueue.element()+" ");
myQueue.add(2);
System.out.print(myQueue.element()+" ");
myQueue.add(3);
System.out.print(myQueue.element()+" ");
myQueue.add(4);
System.out.print(myQueue.element()+" ");
myQueue.add(5);
System.out.println(myQueue.remove());
System.out.print(myQueue.element()+" ");
}
}
以上即是本博客对 栈和队列 的总结，随着后续学习的深入还会同步的对内容进行补充和修改，如能帮助到各位博友将不胜荣幸，敬请斧正