一.前言
本篇博客将从下面两个方面来介绍栈和队列:
1.栈的概念及使用
2.队列的概念及使用
二.栈(stack)
2.1概念
栈
:一种特殊的线性表,其
只允许在固定的一端进行插入和删除元素操作
。进行数据插入和删除操作的一端称为栈 顶,另一端称为栈底。栈中的数据元素遵守后进先出LIFO
(
Last In First Out
)的原则。
压栈:栈的插入操作叫做进栈
/
压栈
/
入栈,
入数据在栈顶
。
出栈:栈的删除操作叫做出栈。
出数据在栈顶
。
2.2栈的使用
代码展示如下:
public static void main(String[] args) {
Stack<Integer> s = new Stack();
s.push(1);
s.push(2);
s.push(3);
s.push(4);
System.out.println(s.size()); // 获取栈中有效元素个数---> 4
System.out.println(s.peek()); // 获取栈顶元素---> 4
s.pop(); // 4出栈,栈中剩余1 2 3,栈顶元素为3
System.out.println(s.pop()); // 3出栈,栈中剩余1 2 栈顶元素为3
if(s.empty()){
System.out.println("栈空");
}else{
System.out.println(s.size());
}
}
2.3栈的模拟实现
从上图中可以看到,
Stack
继承了
Vector
,
Vector
和
ArrayList
类似,都是动态的顺序表,不同的是
Vector
是线程安全的。
代码展示如下:
public class MyStack {
int[] array;
int size;
public MyStack(){
array = new int[3];
}
public int push(int e){
ensureCapacity();
array[size++] = e;
return e;
}
public int pop(){
int e = peek();
size--;
return e;
}
public int peek(){
if(empty()){
throw new RuntimeException("栈为空,无法获取栈顶元素");
}
return array[size-1];
}
public int size(){
return size;
}
public boolean empty(){
return 0 == size;
}
private void ensureCapacity(){
if(size == array.length){
array = Arrays.copyOf(array, size*2);
}
}
}
三.队列(Queue)
3.1概念
队列
:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出
FIFO(First In First Out) 入队列:进行插入操作的一端称为
队尾(
Tail/Rear
)
出队列:进行删除操作的一端称为
队头
(
Head/Front
)。
3.2队列的使用
在
Java
中,
Queue
是个接口,底层是通过链表实现
的。
![](https://i-blog.csdnimg.cn/blog_migrate/9017555899f629014788c524c91f3e68.png)
![](https://i-blog.csdnimg.cn/blog_migrate/7c916edca498a087ab9c2613a57260da.png)
注意:Queue是个接口,在实例化时必须实例化LinkedList的对象,因为LinkedList实现了Queue接口。
代码展示如下:
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<>();
q.offer(1);
q.offer(2);
q.offer(3);
q.offer(4);
q.offer(5); // 从队尾入队列
System.out.println(q.size());
System.out.println(q.peek()); // 获取队头元素
q.poll();
System.out.println(q.poll()); // 从队头出队列,并将删除的元素返回
if(q.isEmpty()){
System.out.println("队列空");
}else{
System.out.println(q.size());
}
}
3.3队列模拟实现
实现代码如下:
public class Queue {
// 双向链表节点
public static class ListNode{
ListNode next;
ListNode prev;
int value;
ListNode(int value){
this.value = value;
}
}
ListNode first; // 队头
ListNode last; // 队尾
int size = 0;
// 入队列---向双向链表位置插入新节点
public void offer(int e){
ListNode newNode = new ListNode(e);
if(first == null){
first = newNode;
// last = newNode;
}else{
last.next = newNode;
newNode.prev = last;
// last = newNode;
}
last = newNode;
size++;
}
// 出队列---将双向链表第一个节点删除掉
public int poll(){
// 1. 队列为空
// 2. 队列中只有一个元素----链表中只有一个节点---直接删除
// 3. 队列中有多个元素---链表中有多个节点----将第一个节点删除
int value = 0;
if(first == null){
return null;
}else if(first == last){
last = null;
first = null;
}else{
value = first.value;
first = first.next;
first.prev.next = null;
first.prev = null;
}
--size;
return value;
}
// 获取队头元素---获取链表中第一个节点的值域
public int peek(){
if(first == null){
return null;
}
return first.value;
}
public int size() {
return size;
}
public boolean isEmpty(){
return first == null;
}
}
3.4循环队列
实际中我们有时还会使用一种队列叫循环队列。
![](https://i-blog.csdnimg.cn/blog_migrate/2ecfe3bb987c1eaed7d91189f1303516.png)
那怎么区分循环队列是否空或者满呢?
我们采用以下方法:
1.
通过添加
size
属性记录
2.
保留一个位置
3.
使用标记
![](https://i-blog.csdnimg.cn/blog_migrate/e82d8c41db8f1f6695d745943652dee7.png)
![](https://i-blog.csdnimg.cn/blog_migrate/59b1014643d8d634c20c501e87459a30.png)
四.双端队列(Deque)
双端队列(
deque
)是指允许两端都可以进行入队和出队操作的队列,
deque
是
“double ended queue”
的简称。 那就说明元素可以从队头出队和入队,也可以从队尾出队和入队。
Deque是一个接口,使用时必须创建LinkedList的对象。
在实际工程中,使用
Deque
接口是比较多的,栈和队列均可以使用该接口。
Deque<Integer> stack = new ArrayDeque<>();//双端队列的线性实现
Deque<Integer> queue = new LinkedList<>();//双端队列的链式实现
五.尾语
这篇博客到这里就结束啦,希望可以给大家带来帮助~~