1.
Pilha
(Pilha)
1.1 Conceito
Pilha: Uma lista linear especial que permite a inserção e remoção de elementos apenas em uma extremidade fixa. Uma extremidade onde a inserção e a exclusão de dados são realizadas é chamada de topo da pilha e a outra extremidade é chamada de fundo da pilha. Os elementos de dados na pilha seguem o
princípio LIFO
(
Last In First Out ).
Push stack: A operação de inserção da pilha é chamada push
/
push
/ push
, e os
dados enviados estão no topo da pilha
.
Pop: A exclusão da pilha é chamada de pop.
Os dados de saída estão no topo da pilha.
1.2 Implementação
1. Use a tabela de sequência para conseguir, ou seja, use o método de inserção de cauda
+
exclusão de cauda
2.
Use a lista vinculada para alcançar, então tanto a cabeça quanto a cauda podem ser
Relativamente falando, a implementação da tabela de sequência é mais simples, então preferimos usar a tabela de sequência para implementar a pilha.
Pilha sequencial baseada em array, o código de implementação é o seguinte:
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
/**
* 基于数组的顺序栈实现
* @param <E>
*/
public class MyStack<E> {
// 当前栈的数据个数
private int size;
// 实际存储数据的动态数组 - ArrayList
private List<E> data=new ArrayList<>();
//入栈
public void push(E val){
//尾插
data.add(val);
size++;
}
//出栈,并返回栈顶元素
public E pop(){
if(isEmpty()){
// 栈为空,没有栈顶元素
throw new NoSuchElementException("stack is empty! cannot pop!");
}
// 删除栈顶元素
E val = data.remove(size - 1);
size --;
return val;
// 等同于 return data.remove(--size);
}
//只返回栈顶元素
public E peek(){
if(isEmpty()){
// 栈为空,没有栈顶元素
throw new NoSuchElementException("stack is empty! cannot peek!");
}
return data.get(size-1);
}
//判断栈是否为空
public boolean isEmpty(){
return size == 0;
}
@Override
public String toString() {
StringBuilder sb=new StringBuilder();
sb.append("[");
for (int i = 0; i < size; i++) {
sb.append(data.get(i));
if(i!=size-1){
// 此时还没到栈顶,还没到数组末尾
sb.append(",");
}
}
sb.append("]");
return sb.toString();
}
}
O método de referência é o seguinte:
public class StackTest {
public static void main(String[] args) {
MyStack<Integer> stack=new MyStack<>();
stack.push(1);
stack.push(2);
stack.push(3);
//打印栈所有元素
System.out.println(stack);
//打印栈顶元素
System.out.println(stack.peek());
//出栈,并打印栈顶元素
stack.pop();
System.out.println(stack);
}
}
Com base nos resultados de entrada acima são os seguintes:
2.
Fila
_
2.1 Conceito
Fila: uma tabela linear especial que permite apenas operações de inserção de dados em uma extremidade e operações de exclusão de dados na outra. a operação de inserção é chamada de cauda da fila ( Cauda/ Traseira ) fora da fila: o final da operação de exclusão é chamado de cabeça da fila
primeiro a entrar, primeiro a sair
2.2 Implementação
A fila também pode ser implementada na estrutura de um array e uma lista encadeada. É melhor usar a estrutura de uma lista encadeada, porque se a estrutura de um array for usada, a eficiência de desenfileiramento e saída de dados no cabeçalho a matriz será relativamente baixa.
A fila básica implementada com base na lista encadeada, o código de implementação é o seguinte:
Classe de interface:
public interface IQueue<E> {
// 入队
void offer(E val);
//出队
E poll();
//返回队首元素
E peek();
//判断队列是否为空
boolean isEmpty();
}
Classe da fila:
import stack_queue.queue.IQueue;
import java.util.NoSuchElementException;
/**
* 基于链表实现的基础队列
* @param <E>
*/
public class MyQueue<E> implements IQueue<E> {
// 链表的每个节点
private class Node{
E val;
Node next;
public Node(E val){
this.val=val;
}
}
// 当前队列中的元素个数
private int size;
// 队首
private Node head;
//队尾
private Node tail;
@Override
public void offer(E val) {
Node node=new Node(val);
if(head==null){
// 此时链表为空
head=tail=node;
}else {
tail.next=node;
tail=node;
}
size++;
}
@Override
public E poll() {
if(isEmpty()){
throw new NoSuchElementException("queue is empty! cannot poll");
}
Node node=head;
head=node.next;
// 将原来头节点脱钩
node.next=null;
size--;
return node.val;
}
@Override
public E peek() {
if(isEmpty()){
throw new NoSuchElementException("queue is empty! cannot peek");
}
return head.val;
}
@Override
public boolean isEmpty() {
return size==0;
}
@Override
public String toString() {
StringBuilder sb=new StringBuilder();
sb.append("[");
// 链表的遍历
for(Node x=head;x!=null;x=x.next){
sb.append(x.val);
if(x.next!=null){
// 还没走到链表尾部
sb.append(",");
}
}
sb.append("]");
return sb.toString();
}
}
O método de referência é o seguinte:
import stack_queue.queue.impl.MyQueue;
public class QueueTest {
public static void main(String[] args) {
IQueue iQueue=new MyQueue();
iQueue.offer(1);
iQueue.offer(2);
iQueue.offer(3);
System.out.println(iQueue);
System.out.println(iQueue.peek());
iQueue.poll();
System.out.println(iQueue);
}
}
Com base nos resultados de entrada acima são os seguintes: