线性表之队列操作

package cn.njupt.mdj.queue;


/*
 * 好好理解思路，才是最重要的，画图可以帮助理解！
 * 
 */

//定义好一个队列的结构,此种队列采用的是this.tail=-1;完成的，也可以用this.tail=0;完成
class Queue{
    //首先定义队列的大小,默认大小
    private int maxSize = 10;
    //为了能够储存任何元素 ，所以采用Object
    private Object[] data;
    //队列的头
    private int head;
    //队列的尾
    private int tail;
    //统计元素的个数
    private int count;
    
    //初始化队列
    public Queue(int size){
        this.maxSize = size;
        this.data = new Object[maxSize];
        this.head = 0;
        //这里为-1，是因为，向队尾添加元素后，队尾会+1，所以就指向了一个元素的位置，所以是要前置++；即++this.tail,而不是this.tail++
        //如果是this.tail++,则会在-1的数组中添加元素，那么就数组越界了，所以明白原理是非常重要的，那么就需要是this.tail=0;来初始化了。
        this.tail = -1;
        this.count = 0;
    }
    
    //添加元素，即向队列中增加元素，
    public void insert(Object data){
        //添加元素之前，首先要判断的是队列中是否还有空间来储存元素，所以首先判读队列是否已满
        if(ifFull()){
            return;
        }
        //如果没有满，即可以填加元素，但是另外需要注意的如果队尾已经到达了数组的顶部，那么为了下次添加元素，那么
        //tail队尾，应该回到第一元素之前的位置，即复原。
        if(this.tail == maxSize-1){//注意是maxSize-1; 而不是maxSize ,因为this.tail是++this.tail
            //因为此时的this.tail所指向的单元中已经存放了元素了
            this.tail = -1;
        }
        //否则即未满，也没有到达数组尾部则正常添加
        this.data[++this.tail] = data;
        //同时元素个数+1；
        this.count++;
        
    }
    
    //判读元素是否满了
    public boolean ifFull(){
        //当this.count 元素个数 增加到 和 元素储存空间一致的时候，即满了。
        return this.count == this.maxSize;
    }
    
    //可以添加当然就可以删除元素，所以删除元素，并返回删除的元素
    public Object remove(){
        if(isEmpty()){//如果元素没有了，即返回null
            return null;
        }
        
        Object temp = this.data[this.head++];//head++;先取元素，然后在向后移动
        //删除元素，同样如果删除的话，如果删除的head的指针到了数组顶部，那么也要还原
        if(this.head == maxSize){//因为是先放后++，所以当this.head元素取走后，然后++，就到到达了末尾
            this.head =0;
        }
        this.count--;
        return temp;
    }
    
    //判断元素是否为空
    public boolean isEmpty(){
        return this.count == 0;
    }
    
    //获取元素个数
    public int getSize(){
        return this.count;
    }
    
    //获取head的元素
    public Object peekHead(){
        return this.data[this.head];
    }
    
    public String toString(){
        if(isEmpty()){
            return "[]";
        }else{
            StringBuffer s = new StringBuffer();
            s.append("[");
            for(int i=this.head;i<this.tail;i++){
                s.append(this.data[i]+",");
            }
            s.append("]");
            return s.toString();
        }
        
    }
    
}

/*
 * 注：当如果初始化，采用的是this.head =0 和 this.tail=0 完成，则
 */
class Queue2{
    private int maxSize;
    private Object[] data;
    private int head;
    private int tail;
    
    public Queue2(int size){
        this.maxSize = size;
        this.data = new Object[this.maxSize];
        //开始初始化
        this.head = 0;
        this.tail = 0;
    }
    
    public void insert(Object data){
        //增加元素，首先要判断元素是否已满了。
        if(isFull()){
            return;
        }
        //元素为满，但如果尾指针已经到了最后一个元素，即最后一个元素已经存放了元素
        if(this.tail == maxSize){
            //只有当this.tail==maxSize,那么说maxSize-1 处存放了元素了。
            //回原
            this.tail = 0;
        }
        //没有，则继续添加元素
        this.data[this.tail++] = data;
        
    }
    
    public boolean isFull(){
        //原因为，采用this.head++ this.tail++; 这样每当添加一个元素的时候是，先放元素，然后在加+1，即指向空处
        //如：this.head=0,this.tail=0;,添加一个元素后，this.head=0;不变，this.tail++；则先
        //把元素放在了0处，然后+1；即this.tail=1; 那么 1-0 = 1 元素
        int size = (this.tail-this.head);
        return size == this.maxSize;
    }
    
    //删除元素
    public Object remove(){
        //首先判读是否为空
        if(isEmpty()){
            return null;
        }
        Object temp = this.data[this.head++];//取出元素
        if(this.head == maxSize){//则最后一个元素也取出来了，还原
            this.head = 0;
        }
        return temp;
    }
    
    public boolean isEmpty(){
        //要判断为空与否，从开始看 this.tail = 0 = this.head　 即为空，
        //当添加元素后 this.tail++ -->先存放后加
        //删除元素的时候 this.head++ -->先删除,在加
        //画图可以看出，只要当两个相同的时候即为空
        return this.head == this.tail;
    }
    
    //获取元素个数
    public int getSize(){
        return this.tail-this.head;
    }
    
    //获取head的元素
    public Object peekHead(){
        return this.data[this.head];
    }
    
    public String toString(){
        if(isEmpty()){
            return "[]";
        }else{
            StringBuffer s = new StringBuffer();
            s.append("[");
            for(int i=this.head;i<this.tail;i++){
                s.append(this.data[i]+",");
            }
            s.append("]");
            return s.toString();
        }
        
    }
}


public class QueueDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Queue2 q = new Queue2(10);
        q.insert("1");
        q.insert("2");
        q.insert("3");
        q.insert("4");
        q.insert("5");
        q.insert("6");
        System.out.println("删除的元素是:"+q.remove());
        System.out.println("获取头元素:"+q.peekHead());
        System.out.println(q.toString());
    }

}


参考文章：http://zengzhaoshuai.iteye.com/blog/1171716

1.队列的顺序存储结构及实现

2.循环队列（顺序结构存储实现）
3.队列的链式存储结构及实现