目录
1 栈(Stack)
1.1 概念
栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈
顶,另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
压栈:栈的插入操作叫做进栈/压栈/入栈,入数据在栈顶。
出栈:栈的删除操作叫做出栈。出数据在栈顶。
1.2 栈的使用
方法 | 功能 |
---|---|
Stack() | 构造一个空的栈 |
E push(E e) | 将e入栈,并返回e |
E pop() | 将栈顶元素出栈并返回 |
E peek() | 获取栈顶元素 |
int size() | 获取栈中有效元素个数 |
boolean empty() | 检测栈是否为空 |
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());
}
}
1.3 栈的应用场景
- 改变元素的序列
- 将递归转化为循环
逆序打印链表
// 递归方式
void printList(Node head){
if(null != head){
printList(head.next);
System.out.print(head.val + " ");
}
}
// 循环方式
void printList(Node head){
if(null == head){
return;
}
Stack<Node> s = new Stack<>();
// 将链表中的结点保存在栈中
Node cur = head;
while(null != cur){
s.push(cur);
cur = cur.next;
}
// 将栈中的元素出栈
while(!s.empty()){
System.out.print(s.pop().val + " ");
}
}
1.4 栈的模拟实现
从上图中可以看到,Stack继承了Vector,Vector和ArrayList类似,都是动态的顺序表,不同的是Vector是线程安全的。
public class MyStack {
public int[] elem;
//不仅可以记录 你当前的元素的个数
// 还可以当做当前可以存放元素的下标
public int usedSize;
public MyStack() {
this.elem = new int[10];
}
/**
* 入栈操作
* @param val
*/
public void push(int val) {
if(isFull()) {
//扩容
this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
}
this.elem[usedSize] = val;
usedSize++;
}
/**
* 判断是不是满了
* @return
*/
public boolean isFull() {
return this.usedSize == this.elem.length;
}
/**
* 出栈 删除
* @return
*/
public int pop() {
if(empty()) {
throw new RuntimeException("栈为空!");
}
/* int val = this.elem[usedSize-1];
this.usedSize--;
return val;*/
this.usedSize--;
return this.elem[usedSize];
}
/**
* 获取栈顶元素 不删除
* @return
*/
public int peek() {
if(empty()) {
throw new RuntimeException("栈为空!");
}
return this.elem[usedSize-1];
}
/**
* 判断是不是空的
* @return
*/
public boolean empty() {
return this.usedSize == 0;
}
/**
* 返回栈的大小
* @return
*/
public int size() {
return this.usedSize;
}
}
1.5 栈、虚拟机栈、栈帧的区别
栈:后进先出的一种数据结构——在java的集合中有对应的实现—Stack,Stack在实现时继承了Vector。
虚拟机栈: jvm为了对数据进行更好的管理,将内存按照不同的需求划分出来的一种结构。栈区:线程私有的,栈区中存放的是函数调用相关的一些信息,主要是栈帧。 当栈区中内存空间不足时,会抛出StackOverflowException。当中的元素(栈帧)是按照数据结构中的栈的特性来实现的
栈帧:一种结构,这种结构与函数调用相关的,内部:局部变量表、操作数栈等。每个方法在运行时,jvm都会创建一个栈帧,然后将栈帧压入到虚拟机栈中,当方法调用结束时,该方法对应的栈帧会从虚拟机栈中出栈
2 队列(Queue)
2.1 概念
队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(First
In First Out) 入队列:进行插入操作的一端称为队尾(Tail/Rear) 出队列:进行删除操作的一端称为队头(Head/Front)
2.2 队列的使用
在Java中,Queue是个接口,底层是通过链表实现的。
方法 | 功能 |
---|---|
boolean offer(E e) | 入队列 |
E poll() | 出队列 |
peek() | 获取队头元素 |
int size() | 获取队列中有效元素个数 |
boolean isEmpty() | 检测队列是否为空 |
注意: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());
}
}
2.3 队列模拟实现
class Node {
public int val;
public Node next;
/**
* 构造方法
* @param val
*/
public Node(int val){
this.val = val;
}
}
public class MyQueue {
public Node front;//队头
public Node rear;//队尾
/**
* 入队-》尾插法
* @param val
*/
public void offer(int val) {
Node node = new Node(val);
if(this.front == null) {
this.front = node;
this.rear = node;
}else {
this.rear.next = node;
this.rear = node;
}
}
/**
* 返回队头元素
* @return
*/
public int peek() {
if(isEmpty()) {
throw new RuntimeException("队列为空!");
}
return this.front.val;
}
/**
* 出队
* @return
*/
public int poll() {
if(isEmpty()) {
throw new RuntimeException("队列为空!");
}
int old = this.front.val;
this.front = this.front.next;
return old;
}
/**
* 是否为空
* @return
*/
public boolean isEmpty() {
return this.front == null;
}
}
3 双端队列
双端队列(deque)是指允许两端都可以进行入队和出队操作的队列,deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队,也可以从队尾出队和入队。
Deque是一个接口,使用时必须创建LinkedList的对象。