栈、队列、优先队列

栈

通常栈有顺序栈和链栈两种存储结构，这两种存储结构的不同，则使得实现栈的基本运算的算法也有所不同。
栈固定的方法：添加、弹出、获取最顶上元素、判断是否非空、判断是否已满（这里是写的是无限大栈，模仿ArrayList扩容）。
栈是先进先出，类似于在篮子里面取衣服，永远只能取到最上面的衣服，放置衣服也是一样，永远也是放在最上面。

import java.util.Arrays;

/**
 * 简单模拟线性栈（数组版）
 * @author orange
 *
 */
public class StackTest {
    private Object[] nodesObjects=new Object[10];//存放元素的数据
    private int size=-1;//顶层元素的下标

    //增加
    private void add(Object obj){
        chekLength(size+1);//检查容量
        nodesObjects[++size]=obj;
    }
    //弹出
    private Object pop(){
        return nodesObjects[size--];
    }
    //查看
    private Object show(){
        return nodesObjects[size];
    }
    //是否为空
    private boolean isNull(){
        return size==-1;
    }
    //清空
    private  void clear(){
        Arrays.fill(nodesObjects, null);
        size=-1;
    }
    //长度检测
    public void chekLength(int newLength){
        int oldLength=nodesObjects.length;
        if(oldLength<newLength){
            //默认扩容
            oldLength=oldLength+(oldLength>>1);
            newLength=Math.max(oldLength, newLength);
            Object[] temp=new Object[newLength];
            System.arraycopy(nodesObjects, 0, temp, 0, nodesObjects.length);
            nodesObjects=temp;
        }
    }
}

队列

队列也有顺序栈和链栈两种存储结构，两种存储结构的不同，则使得实现栈的基本运算的算法也有所不同。
队列固定的方法：入队、出队、置空队列、判断是否为空、判断是否已满。
队列一头是只进不出（入队）另一头是只出不进(出队)，类似于排队买票，排在前面的人先买到票，排在后面的人后买到票（万一票卖完了呢(^__^) ……那就都买不到）。

public class QueueTest {

    public Object[]values=null//存放队列的数组;
    public int start=0;//开始下标
    public int end=-1;   //结束下标
    public int size=0;  //队列元素个数



    //创建一个队列
    public void createQueue(int legth){
        values=new Object[legth];
    }
    //判断为空
    public boolean isNull(){
        return 0==size;
    }
    //判断是否满
    public boolean isFull(){
        return size==values.length;
    }
    //入队
    public boolean push(Object obj){
        if(isFull()){
            return false;
        }
        size++;
        if(end==values.length-1){//当开始下标到达最后一位但队列又没有满 表示前面一定还有位置。
            end=-1;
        }
        values[++end]=obj;
        return true;
    }
    //出队
    public Object pop(){
        if(isNull()){
            return null;
        }
        size--;
        Object temp = values[start];
        if(start==values.length-1){ //当开始下标到达最后一位但队列又没有满 表示前面一定还有位置。
            start=-1;
        }
        start++;
        return temp;
    }

    //查看（不弹出）
    public Object show(){
        if(isNull()){
            return null;
        }
        return values[start];
    }
}

优先队列

队列也有顺序栈和链栈两种存储结构，两种存储结构的不同，则使得实现栈的基本运算的算法也有所不同。
队列固定的方法：入队、出队、置空队列、判断是否为空、判断是否已满。
优先队列不是先进先出也不是先进后出，优先队列是按照优先级来的决定谁先出去的，类似于你要坐飞机去迪拜做乞丐但是飞机马上要起飞了你却还没取票，这时候因为你比较急你选择插队你跑到队伍的最前面去了，最后你取到票到如愿以偿的做了迪拜的乞丐。谁的优先级高谁就在前面。

/**
 * 优先队列
 * @author orange
 *数组的尾巴为队列的头，数组的头为队列的尾巴，也就是按照数组下标倒着来的。
 *优先级队列按照值越大优先级越高，假如添加的值和队列里面的相等则放到该值的最前。
 */
public class PriorityQueueTest {
    public int[]values=new int[10];//存储元素(默认容量为10)
    public int size=0;//元素个数


    //构造方法
    public void createQueue(int size){
        if(size!=10){
            values=new int[size];
        }
    }
    //判断为空
    public boolean isNull(){
        return size==0;
    }
    //判断是否满
    public boolean isFull(){
        return size==values.length;
    }
    //入队
    public boolean pull(int value){
        if(isFull()){
            System.out.println("满了！！");
            return false;
        }
        int i=0;//入队值的下标
        if(size!=0){
            i=size-1;
            for(;i>=0;i--){
                if(values[i]>value){
                    values[i+1]=values[i];//向后面挪位置
                }else{
                    break;//发现小于或者等于前面的值时，结束操作。
                }
            }
            //现在 i+1的值就是value需要放置的下标
            i++;
        }
        values[i]=value;
        size++;
        return true;
    }
    //出队
    public int pop(){
        if(isNull()){
            System.out.println("没有值！");
            return -1;
        }
        return values[--size];
    }
    //查看不出队
    public int show(){
        if(isNull()){
            System.out.println("没有值！");
            return -1;
        }
        int index=size-1;
        return values[index];
    }
}