栈和队列
栈stack
- 栈也是一种线性结构
- 相比数组，栈对应的操作数数组的子集
- 只能从一端添加元素，也只能从一端取出元素
- 这一端称为栈顶
- 栈是一种后进先出的数据结构
- Last in Firt out(LIFO)
- 在计算机的世界里，栈拥有者不可思议的作用
栈的应用
- 无处不在的undo操作(撤销)
- 沉迷 学习 不法
- 程序调用的系统栈
- 从A函数调用B函数，B函数在调用C函数
- A2，表示进行到A函数的第二行
当一个子过程可以自动回到上层调用继续执行的原因，因为有系统栈去记录每一个中断的点。子过程的调用实现机理就是如此。对于递归的理解会在后续介绍。
栈的实现
Stack
- void push(E)
- E pop()
- E peek()
- int getSize()
- boolean isEmpty()
从用户的角度看，支持这些操作就好
具体底层实现，用户不关心
实际底层有多种实现方式
采用多态的方式
public Interface Stack<E>{
int getSize();
boolean isEmpty();
void push(E e);
E pop();
E peek();
}
public class ArrayStack<E> implements Stack<E>{
Array<E> array;
public ArrayStack(int getCapacity){
array = new Array<>(capacity);
}
public ArrayStack(){
array = new Array<>();
}
@Override
int getSize(){
return array.getSise;
}
@Override
boolean isEmpty(){
return array.isEmpty();
}
@Override
public int getCapacity(){
return array.getCapacity();
}
@Override
void push(E e){
arraty.addLasy(e);
}
@Override
E pop(){
array.removeLast();
}
@Override
E peek(){
return array.getLast();
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append("Stack: ");
res.append("[]");
for(int i = 0 ; i < arr.getSize();i++){
res.append(array.get(i));
if(i!=array.getSize()-1)
res.append(", ");
}
res.append("] top");
return res.toString();
}
}
对于array新加如下方法
public E getLast(){
return get(size-1);
}
public E getFirst(){
return get(0);
}
栈的另一个应用，括号匹配
这是二十家大公司对于该题的面试形式
栈顶元素反映了在嵌套的层次关系中，最近的需要匹配的元素
Class Solution{
public boolean isValid(String s){
Stack<Character> stack = new Stack<>();
for(int i = 0 ; i <s.length();i++)
char c = s.charAt(i);
if(c=='('||c=='['||c=='{')
stack.push(c);
else{
if(stack.isEmpty())return false;
char topChar = stack.pop();
if(c==')'&&topChar!='(')return false;
if(c==']'&&topChar!='[')return false;
if(c=='}'&&topChar!='{')return false;
}
return stack.isEmpty();
}
}
队列
-
队列也是一种线性结构
-
相比数组，队列对应的操作是数组的子集
-
只能从一端添加元素，从另一端取出元素
-
队列是一种先进先出的数据结构（先到先得）
-
First Iｎ First Out(FIFO)
Queue<E>
- void enqueue(E)//入队
- E dequeue()//出队
- E getFront()//获取队首元素
- int getSize()
- boolean isEmpty()//是否为空
public interface Queue<E>{
void enqueue(E)//入队
E dequeue()//出队
E getFront()//获取队首元素
int getSize()
boolean isEmpty()//是否为空
}
public class ArrayQueue<E> implements Queue<E>{
private Array<E> array;
public ArrayQueue(int capacity){
array = new Array<>(capacity);
}
public ArrayQueue(){
array = new Array<>();
}
@Override
public int getSize(){
return array.getSize();
}
@Override
public int isEmpty(){
return array.isEmpty();
}
@Override
public int getCapacity(){
return array.getCapacity();
}
@Override
public int enqueue(){
array.addLast(e);
}
@Override
public int dequeue(){
return array.removeFirst();
}
@Override
public E getFront(){
return array.getFirst();
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append("Queue: ");
res.append("front [");
for(int i = 0 ; i < arr.getSize();i++){
res.append(array.get(i));
if(i!=array.getSize()-1)
res.append(", ");
}
res.append("] tail");
return res.toString();
}
}
循环队列
数组队列的问题
（tail+1)%c==front 队列满
对于循环我们可以查看自己的钟表就能理解了循环的意思。形成一个环，大小由数组容积决定。
public class LoopQueue<E> implements Queue<E>{
private E[] data;
private int front,tail;
private int size;
public LoopQueue(int capacity){
data =(E[]) new Obejct[capacity+1];
front = 0;
tail = 0;
size = 0;
}
public LoopQueue(){
this(10);
}
public int getCapacity(){
return data.length-1;
}
@Override
public boolean isEmpty(){
return front==tail;
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append("Queue: size = %d, capacity = %d",size,getCapacity());
res.append("front [");
for(int i = front ; i ! = tail;(i+1)%data.length){
res.append(array.get(i));
if((i+1)%data.length!=tail)
res.append(", ");
}
res.append("] tail");
return res.toString();
}
}
循环队列的实现
@Override
public void enqueue(E e){
if((tail+1)%data.length==front)resize(getCpacity()*2);
data[tail] = e;
tail = (tail+1)%data.length;
size++;
}
@Override
public E dequeue(){
if(isEmpty())
throw new IllegalArgumentException("cannot dequeue from an empty queue");
E ret = data[front];
data[front] = null;
front = (front+1)%data.length;
size--;
if(size == getCapacity()/4&&resize(getCapacity()/2!=0)
resize(getCapacity()/2);
return ret;
}
private void resize(int newCapacity){
E[] newData =(E[]) new Object[newCapacity+1];
for(int i = 0; i < size ;i++){
newData[i] = data[(i+front) % data.length];
}
data = newData;
front = 0;
tail = size;
}
@Override
public E getFront(){
if(isEmpty())
throw new IllegalArgumentException("from an empty queue");
return data[front];
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append("Queue: size = %d, capacity = %d",size,getCapacity());
res.append("front [");
for(int i = front ; i ! = tail;(i+1)%data.length){
res.append(array.get(i));
if((i+1)%data.length!=tail)
res.append(", ");
}
res.append("] tail");
return res.toString();
}
数组队列和循环队列的比较
栈和队列习题集
使用动态数组实现栈和队列，但是现在如果没有这种结果的话。我们需要用栈，应该著怎么实现呢？
使用队列实现栈
使用栈实现队列
