关于栈和队列的重要问题

这几天我们学习了栈和队列，栈的特点是先进的后出，队列的特点是先进先出，举个例子就像你在食堂排队买饭是一样的道理，你最后排队的人肯定要等你前面排队的人都出去了，也就是打完饭了你才能去打饭，队列就是这个道理。下面我将把栈和队列的代码写出来供大家参考
下面是栈的代码：
import java.util.Arrays;
import java.util.Stack;

public class MyStack {
public T[] elem;//用到了泛型，只在编译时期有效
public int top;
public MyStack(){
this.elem = (T[])new Object[10];//
}
public void push(T val){
if(full()){
this.elem = Arrays.copyOf(this.elem , 2*this.elem.length);
}
this.elem[this.top++] = val;
}
public T pop(){
if(empty()){
throw new RuntimeException(“栈为空”);
}
T data = this.elem[this.top-1];
this.top–;
return data;
}
public boolean empty(){
if(this.top == 0){
return true;
}
return false;
}
public boolean full(){
return this.top == this.elem.length;
}
public T peep(){
if(empty()){
throw new RuntimeException(“栈是空的”);
}
T data = this.elem[this.top-1];
return data;
}
public int size(){
return this.top;
}

}
在我们实现循环队列的时候其实最大的问题是我们怎么知道这个队列什么时候为空，我们定义了两个节点一个指向队列的头部，一个指向队列的尾部，当对头和对位相遇时代表循环队列为空。
还有就是队列在从数组的最大位置向零号位置移动的时候不能直接加一，只能利用我们的%，尾节点加一%数组的长度，余数为几就在几号下标的位置去，这样就形成了循环。
public class MyCircularQueue {
public int[] elem ;
public int front;
public int tail;
public MyCircularQueue(int k){
this.elem = new int[k+1];

}
public boolean enQueue(int value){
    if(isFull()){
        return false;
    }
    this.elem[this.tail] = value;
    this.tail = ((this.tail+1)%elem.length);
    return true;
}
public boolean isFull(){
    if(this.front== (this.tail+1)%(this.elem.length)){
        return true;
    }
    return false;
}
public boolean deQueue(int value){
    if(empty()){
        throw new RuntimeException("队列为空");
    }
    this.front = (this.front+1)%this.elem.length;
    return true;
}
public boolean empty(){
    if(this.front == this.tail){
        return true;
    }
    return false;
}
public int Front(){
    if(empty()){
        return -1;
    }
    return this.elem[this.front];
}
public int Tail(){
    if(empty()){
        return -1;
    }
     int index = this.tail == 0 ? this.elem.length-1 : this.tail-1;
    return index;
}

}
接下来分析下PriorityQueue,这个队列底层是一个小堆，在排序的题目或者让你计算从小到大，从大到小进行输出时可以使用这一队列，当我们想要使他的底层变成大堆时我们的以实例化一个匿名内部类Compartor实现这个接口重写其中的compaer
方法使o2-o1；就可以实现一个大堆；
比如说topk问题，从十万个数据中取出前k个最小的元素
public class TopK{
public static Integer[] topK(int[] array,int k){
PriorityQueue pq = new PriorityQueue<>(new Compartor<>(){
@Override
public int compare(Integer o1,Integer o2){
return o2-o1;
}
});
for(int i=0;i<array.length;i++){
if(pq.size()<k){
pq.add(array[i])
}else{
if(pq!= null&&pq.peek()>k){
pq.pop();
pq.add(array[i]);
}
}
}
Integer[] ret = new Integeer[k];
for(int i = 0;i<k;i++){
int v = pq.pop();
ret[i] = v;
}
public static void main(String[] args){
int[] array = {12,1,3,4,5};
Integer[] ret = topK(array,4);
System.out.println(Arrays.toString(ret));

}

}