Java开篇八：Stack and Queue
感恩节是美国人民独创的一个古老节日，也是美国人合家欢聚的节日。1941年，美国国会正式将每年11月第四个星期四定位“感恩节”。
今天是小雪，也注意大家多穿点衣服，注意保暖，别冻着了。
定义
栈：后进先出（LIFO-last in first out）:最后插入的元素最先出来。
队列：先进先出（FIFO-first in first out）:最先插入的元素最先出来。
栈(Stack)
栈(stack)，也可以叫做堆栈，是一种容器类型的数据结构，可以存入数据元素、访问元素以及删除元素。
特点：只允许在一端进行操作，采用了后进先出（Last in Fist out）的原理。
下面采用顺序表的形式来实现
class Stack(object): """栈""" def __init__(self): self.__list = [] def push(self, item): """添加一个新元素到栈顶，就是将这个item放到append到最后面""" self.__list.append(item) def pop(self): """弹出栈顶的元素，采用list中的pop方法""" return self.__list.pop() def peek(self): """返回栈顶的元素，就是弹出来最后的一个元素""" if self.__list: return self.__list[-1] else: return None def is_empty(self): """判断栈是不是为空的""" return self.__list == [] def size(self): """返回栈的元素个数""" return len(self.__list)
if __name__ == '__main__': s = Stack() print(s.is_empty()) # True print(s.size()) # 0 s.push(1) s.push(2) s.push(3) print(s.is_empty()) # False print(s.peek()) # 3 print(s.size()) # 3 s.pop() s.pop() print(s.is_empty()) # False print(s.size()) # 1
二、队列(Queue)
队列是一种只允许在一端进行插入操作，另外一端进行删除操作的线性表
特点是：先进先出（First in First out）。举个例子，就是排队买票去动物园，先排队买到票的小伙伴就先进去。其效果如下图所示：
class Queue(object): """队列""" def __init__(self): self.__list = [] def enqueue(self, item): """往队列中添加一个元素""" self.__list.append(item) def dequeue(self): """将队列头部的一个元素删除""" self.__list.pop(0) def is_empty(self): """判断一个队列是不是空的""" return self.__list==[] def size(self): """返回队列的大小""" return len(self.__list)
if __name__ == '__main__': q = Queue() print(q.is_empty()) # True print(q.size()) # 0 q.enqueue(1) q.enqueue(2) q.enqueue(3) q.enqueue(4) print(q.is_empty()) # False print(q.size()) # 4 q.dequeue() q.dequeue() print(q.is_empty()) # False print(q.size()) # 2
Stack and Queue
Java里有一个叫做Stack的类，却没有叫做Queue的类（它是个接口名字）。当需要使用栈时，Java已不推荐使用Stack，而是推荐使用更高效的ArrayDeque；既然Queue只是一个接口，当需要使用队列时也就首选ArrayDeque了（次选是LinkedList）。
讲解：
要讲栈和队列，首先要讲Deque接口。Deque的含义是“double ended queue”，即双端队列，它既可以当作栈使用，也可以当作队列使用。下表列出了Deque与Queue相对应的接口：
下表列出了Deque与Stack对应的接口：
上面两个表共定义了Deque的12个接口。添加，删除，取值都有两套接口，它们功能相同，区别是对失败情况的处理不同。一套接口遇到失败就会抛出异常，另一套遇到失败会返回特殊值（false或null）。除非某种实现对容量有限制，大多数情况下，添加操作是不会失败的。虽然Deque的接口有12个之多，但无非就是对容器的两端进行操作，或添加，或删除，或查看。明白了这一点讲解起来就会非常简单。
ArrayDeque和LinkedList是Deque的两个通用实现，由于官方更推荐使用AarryDeque用作栈和队列，加之上一篇已经讲解过LinkedList，本文将着重讲解ArrayDeque的具体实现。
从名字可以看出ArrayDeque底层通过数组实现，为了满足可以同时在数组两端插入或删除元素的需求，该数组还必须是循环的，即循环数组（circular array），也就是说数组的任何一点都可能被看作起点或者终点。ArrayDeque是非线程安全的（not thread-safe），当多个线程同时使用的时候，需要程序员手动同步；另外，该容器不允许放入null元素。
上图中我们看到，head指向首端第一个有效元素，tail指向尾端第一个可以插入元素的空位。因为是循环数组，所以head不一定总等于0，tail也不一定总是比head大。
案例：
2.用数组实现栈和队列
实现栈：
由于数组大小未知，如果每次插入元素都扩展一次数据（每次扩展都意味着构建一个新数组，然后把旧数组复制给新数组），那么性能消耗相当严重。
这里使用贪心算法，数组每次被填满后，加入下一个元素时，把数组拓展成现有数组的两倍大小。
每次移除元素时，检测数组空余空间有多少。当数组里的元素个数只有整个数组大小的四分之一时，数组减半。
为什么不是当数组里的元素个数只有整个数组大小的二分之一时，数组减半？考虑以下情况：数组有4个元素，数组大小为4个元素空间。此时，加一个元素，数组拓展成8个空间；再减一个元素，数组缩小为4个空间；如此循环，性能消耗严重。
具体代码（Java）:
public ResizingArrayStackOfStrings(){ s=new String[1]; int N = 0;}pubilc void Push(String item){ //如果下一个加入元素超出数组容量，拓展数组 if(N == s.length) Resize(2 * s.length); s[N++] = item;}private void Resize(int capacity){ String[] copy = new String[capacity]; //将旧数组元素复制给新数组 for(int i=0; i<N; i++) copy[i] = s[i]; s = copy;}public String Pop(){ String item = s[--N]; s[N] = null;//剩余元素只占数组四分之一空间时，数组减半 if(N>0 && N=s.length/4) Resize(s.length/2); return item;}
实现队列
与栈类似：
数组每次被填满后，加入下一个元素时，把数组拓展成现有数组的两倍大小。
每次移除元素时，检测数组空余空间有多少。当数组里的元素个数只有整个数组大小的四分之一时，数组减半。
不同之处在于：
由于是先进先出，移除是从队列的最前端开始的。所以当我们移除数个数据后，队列数据是存储在数组的中间部分的。令队列数据的尾端数据ID为Num,首端数据ID为HeadIndex，则Num - HeadIndex为队列数据元素个数。
当队列数据元素个数为整个数组空间的四分之一时，数组减半，且队列数据左移至数组最左端。即Num-=HeadIndex；HeadIndex=0；
具体代码：
.h:UCLASS()class ALGORITHM_API AStackAndQueuesExerciseTwo : public AActor{ GENERATED_BODY() public: // Sets default values for this actor's properties AStackAndQueuesExerciseTwo(); // Called every frame virtual void Tick(float DeltaTime) override; //输入 void Enqueue(int Input); //重构数组（拓展或缩小） void Resize(int Capacity); //输出且移除 int Dequeue(); //队列里没元素了？ bool IsEmpty();protected: // Called when the game starts or when spawned virtual void BeginPlay() override;public: private: //记录数组中有多少个Int int Num; //队列数组 TArray<int> MyIntArray; //记录下一个移除的数据ID int HeadIndex;};.cpp:AStackAndQueuesExerciseTwo::AStackAndQueuesExerciseTwo(){ // Set this actor to call Tick() every frame. You can turn this off to improve performance if you don't need it. PrimaryActorTick.bCanEverTick = true; //一开始数组没成员 Num = 0; HeadIndex = 0; //数组中有一个假元素 MyIntArray.Add(0);}// Called when the game starts or when spawnedvoid AStackAndQueuesExerciseTwo::BeginPlay(){ Super::BeginPlay(); //测试 Enqueue(1); Enqueue(2); Enqueue(3); Enqueue(4); Enqueue(5); Dequeue(); Dequeue(); Dequeue(); //队列数组成员 for (int i = HeadIndex; i < Num; i++) { UKismetSystemLibrary::PrintString(this, "i: " + FString::FromInt(i) + " End: " + FString::FromInt(MyIntArray[i])); } //队列数组的容量 UKismetSystemLibrary::PrintString(this, "MyIntArray.Num(): " + FString::FromInt(MyIntArray.Num()));}// Called every framevoid AStackAndQueuesExerciseTwo::Tick(float DeltaTime){ Super::Tick(DeltaTime);}void AStackAndQueuesExerciseTwo::Enqueue(int Input){ //如果队列数组已满，拓展数组 if (Num == MyIntArray.Num()) { Resize(2 * MyIntArray.Num()); } //拓展或者数组有空位时，添加元素 if (Num < MyIntArray.Num()) { MyIntArray[Num] = Input; } Num++;}void AStackAndQueuesExerciseTwo::Resize(const int Capacity){ //int a[] = new int[Capacity]; TArray<int> Copy; //添加数个假元素填充数组 for (int i = 0; i < Capacity; i++) { Copy.Add(0); } //将队列数组赋值给Copy数组，如果是缩小数组，则把队列数组左移，节省空间 for (int i = HeadIndex; i < Num; i++) { Copy[i - HeadIndex] = MyIntArray[i]; } MyIntArray = Copy;}int AStackAndQueuesExerciseTwo::Dequeue(){ //判断数组是否为空 if (IsEmpty()) { UKismetSystemLibrary::PrintString(this, "No Element Exist!!!"); return 0; } else { UKismetSystemLibrary::PrintString(this, "Dequeue: " + FString::FromInt(MyIntArray[HeadIndex])); } HeadIndex++; //如果移除元素后，所剩元素为数组空间的四分之一，则数组减半 if ((Num - HeadIndex) != 0 && (Num - HeadIndex) == (MyIntArray.Num() / 4)) { Resize(MyIntArray.Num() / 2); //移除空间后，队列数组左移，节省空间 Num -= HeadIndex; HeadIndex = 0; return MyIntArray[HeadIndex]; } else { return MyIntArray[HeadIndex - 1]; } }//如果下一个要移除的数据不存在，则为空数组bool AStackAndQueuesExerciseTwo::IsEmpty(){ return HeadIndex >= Num;}
方法剖析
无论我蜷缩在屋子里 还是远在另一个地方的冬天。纷纷扬扬的雪 都会落在我正在经历的一段岁月里。
addFirst()
addFirst(E e)的作用是在Deque的首端插入元素，也就是在head的前面插入元素，在空间足够且下标没有越界的情况下，只需要将elements[--head] = e即可。
实际需要考虑：1.空间是否够用，以及2.下标是否越界的问题。上图中，如果head为0之后接着调用addFirst()，虽然空余空间还够用，但head为-1，下标越界了。下列代码很好的解决了这两个问题。
//addFirst(E e)public void addFirst(E e) { if (e == null)//不允许放入null throw new NullPointerException(); elements[head = (head - 1) & (elements.length - 1)] = e;//2.下标是否越界 if (head == tail)//1.空间是否够用 doubleCapacity();//扩容}
上述代码我们看到，空间问题是在插入之后解决的，因为tail总是指向下一个可插入的空位，也就意味着elements数组至少有一个空位，所以插入元素的时候不用考虑空间问题。
下标越界的处理解决起来非常简单，head = (head - 1) & (elements.length - 1)就可以了，这段代码相当于取余，同时解决了head为负值的情况。因为elements.length必需是2的指数倍，elements - 1就是二进制低位全1，跟head - 1相与之后就起到了取模的作用，如果head - 1为负数（其实只可能是-1），则相当于对其取相对于elements.length的补码。
下面再说说扩容函数doubleCapacity()，其逻辑是申请一个更大的数组（原数组的两倍），然后将原数组复制过去。过程如下图所示：
图中我们看到，复制分两次进行，第一次复制head右边的元素，第二次复制head左边的元素。
//doubleCapacity()private void doubleCapacity() { assert head == tail; int p = head; int n = elements.length; int r = n - p; // head右边元素的个数 int newCapacity = n << 1;//原空间的2倍 if (newCapacity < 0) throw new IllegalStateException("Sorry, deque too big"); Object[] a = new Object[newCapacity]; System.arraycopy(elements, p, a, 0, r);//复制右半部分，对应上图中绿色部分 System.arraycopy(elements, 0, a, r, p);//复制左半部分，对应上图中灰色部分 elements = (E[])a; head = 0; tail = n;}
三、双端队列(Deque)
双端队列具有队列和栈的数据结构。
class Deque(object): "双端队列" def __init__(self): self.items = [] def is_empty(self): """判断双端队列是不是空""" return self.items ==[] def add_front(self, item): """从队头添加元素""" self.items.insert(0, item) def add_rear(self, item): """从队尾添加元素""" self.items.append(item) def remove_front(self): """从队头删除元素""" return self.items.pop(0) def remove_rear(self): """从队尾删除元素""" return self.items.pop() def size(self): """返回队列大小""" return len(self.items)
if __name__ == '__main__': deque = Deque() deque.add_front(1) deque.add_front(2) deque.add_rear(3) deque.add_rear(4) print(deque.size()) # 4 print(deque.remove_front()) # 2 print(deque.remove_front()) # 1 print(deque.remove_rear()) # 4 print(deque.remove_rear()) # 3
无论我蜷缩在屋子里 还是远在另一个地方的冬天。纷纷扬扬的雪 都会落在我正在经历的一段岁月里。
addLast()
addLast(E e)的作用是在Deque的尾端插入元素，也就是在tail的位置插入元素，由于tail总是指向下一个可以插入的空位，因此只需要elements[tail] = e;即可。插入完成后再检查空间，如果空间已经用光，则调用doubleCapacity()进行扩容。
public void addLast(E e) { if (e == null)//不允许放入null throw new NullPointerException(); elements[tail] = e;//赋值 if ( (tail = (tail + 1) & (elements.length - 1)) == head)//下标越界处理 doubleCapacity();//扩容}
下标越界处理方式addFirt()中已经讲过，不再赘述。
pollFirst()
pollFirst()的作用是删除并返回Deque首端元素，也即是head位置处的元素。如果容器不空，只需要直接返回elements[head]即可，当然还需要处理下标的问题。由于ArrayDeque中不允许放入null，当elements[head] == null时，意味着容器为空。
public E pollFirst() { E result = elements[head]; if (result == null)//null值意味着deque为空 return null; elements[h] = null;//let GC work head = (head + 1) & (elements.length - 1);//下标越界处理 return result;}
pollLast()
pollLast()的作用是删除并返回Deque尾端元素，也即是tail位置前面的那个元素。
public E pollLast() { int t = (tail - 1) & (elements.length - 1);//tail的上一个位置是最后一个元素 E result = elements[t]; if (result == null)//null值意味着deque为空 return null; elements[t] = null;//let GC work tail = t; return result;}
无论我蜷缩在屋子里 还是远在另一个地方的冬天。纷纷扬扬的雪 都会落在我正在经历的一段岁月里。
peekFirst()
peekFirst()的作用是返回但不删除Deque首端元素，也即是head位置处的元素，直接返回elements[head]即可。
public E peekFirst() { return elements[head]; // elements[head] is null if deque empty}
peekLast()
peekLast()的作用是返回但不删除Deque尾端元素，也即是tail位置前面的那个元素。
public E peekLast() { return elements[(tail - 1) & (elements.length - 1)];}
栈和队列(Stack and Queue)
栈，先进后出，像桶一样，先放进去，最后才出来。
队列，先进先出，就像管道一样，自来水管道，先进先出
总结：
我这计划：246生活文章，135技术文章 （星期一：技术文章）
这Stack and Queue也是集合的范畴，只是我们平常用不到，他属于底层的东西，用法跟arrylist差不多。
再说了，我们这做应用开发的很少用到栈，当需要使用栈时，Java已不推荐使用Stack，而是推荐使用更高效的ArrayDeque；既然Queue只是一个接口，当需要使用队列时也就首选ArrayDeque了（次选是LinkedList）。
栈，先进后出，像桶一样，先放进去，最后才出来。队列，先进先出，就像管道一样，自来水管道，先进先出
希望这一篇文章可以帮助你对栈和队列有一定的认识
从这章我看到一个问题Java这我一辈子都不可能学得透彻，只有日积月累慢慢的累计，一天一天的进步一点，加油吧！打工人。
