java编程（一）队列

1. 用数组实现一个顺序队列

   package sequentialQueue;
   
   public interface IQueue {
   
       //初始化
       public  void init();
       //入队
       public void enter(Object object) throws Exception;
       //出队
       public Object depaeture() throws Exception;
       //清空队列
       public void clear();
       //获取队列大小
       public int getSize();
       //判断队满
       public boolean isFull();
       //判断队空
       public boolean isEmpty();
   
   }
   package sequentialQueue;
   
   public class Queue implements IQueue{
   
       private static final int MAX_SIZE=100;
       //数组队列
       private Object[] queue;
       //头指针
       private int front;
       //尾指针
       private int rear;
       //初始化大小
       private int length;
   
   
       @Override
       public void init() {
           queue=new Object[this.length+1];
           front=rear=0;
       }
   
       @Override
       public void enter(Object object) throws  Exception{
           if(isFull()){
               throw new Exception("队列已满！");
           }
           queue[rear]=object;
           rear=(rear+1)%queue.length;
       }
   
       @Override
       public Object depaeture() throws Exception{
           if (isEmpty()){
               throw new Exception("队列为空！");
           }
           Object object=queue[front];
           queue[front]=null;
           front=(front+1)%queue.length;
           return object;
       }
   
       @Override
       public void clear() {
           queue=null;
           queue=new Object[this.length];
       }
   
       @Override
       public int getSize() {
           return (rear-front+queue.length)%queue.length;
       }
   
       @Override
       public boolean isFull() {
           return (rear+1)%queue.length == front;
       }
   
       @Override
       public boolean isEmpty() {
           return front==rear;
       }
   
       public Queue(){
           this.length=MAX_SIZE;
           init();
       }
   
       public Queue(int length){
           this.length=length;
           init();
       }
   
       public static void  main(String[] args)throws  Exception{
           Queue queue=new Queue(5);
           char[] data = new char[]{'好','的','长','度','注','意'};
           try {
               for (int i = 0; i <data.length ; i++) {
                   System.out.println("入队数据为："+data[i]);
                   queue.enter(data[i]);
               }
           }catch (Exception e){
               e.printStackTrace();
           }
           System.out.println("队列大小为："+queue.getSize());
           try {
               while (!queue.isEmpty()){
                   System.out.println("出队数据为："+queue.depaeture());
               }
           }catch (Exception e){
               e.printStackTrace();
           }
           System.out.println("队列是否为空："+queue.isEmpty());
   
       }
   }
   

    

2. 用链表实现一个链式队列

   package chainQueue;
   
   public interface ICQueue {
       //判空
       public boolean isEmpty();
       //添加元素
       public boolean addQueue(Object object);
       //删除元素
       public boolean deleteQueue();
   }
   package chainQueue;
   
   
   
   public class CQNode {
       CQNode next;
       Object object;
   
       public CQNode(CQNode next,Object object){
           this.next=next;
           this.object=object;
       }
   
       public void setNext(CQNode next){
           this.next=next;
       }
   
       public CQNode getNext(){
           return next;
       }
   
       public void setObject(Object object){
           this.object=object;
       }
   
       public Object getObject(){
           return object;
       }
   
   
   }
   package chainQueue;
   
   
   public class LinkQueue implements ICQueue {
   
        CQNode front;
        CQNode rear;
   
       int size=0;
   
       //初始化
       public LinkQueue(){
           front=rear=null;
       }
   
       @Override
       public boolean isEmpty() {
           return size==0?true:false;
       }
   
       @Override
       public boolean addQueue(Object object) {
           if (size==0){
               front=new CQNode(null,object);
               rear=front;
               size++;
               return true;
           }
           CQNode n=new CQNode(null,object);
           rear.setNext(n);
           rear=n;
           return true;
       }
   
       @Override
       public boolean deleteQueue() {
           if (isEmpty()){
               System.out.println("队列为空!");
               return false;
           }
           front = front.next;
           size--;
           return true;
       }
   
   
       public static void main(String[] args)throws  Exception{
           LinkQueue linkQueue=new LinkQueue();
   
           linkQueue.addQueue(1);
           linkQueue.addQueue(2);
           linkQueue.addQueue(3);
           linkQueue.addQueue(4);
           System.out.println("队列长度为："+linkQueue.size);
           linkQueue.deleteQueue();
       }
   }
   

    

3. 实现一个循环队列

   package circularQueue;
   
   public class CirQueue {
       /*
       * 数组实现的循环队列，需要注意的一点，
       * 当队列为空和满的时候，我们需要去区别一下，
       * 因为，在队列为满的时候我们牺牲掉一个空间，使得rear的下一个位置为front，用来区分
       * */
   
       Object[] queue;
       int front;
       int rear;
   
       public CirQueue(){
           /*
           * 调用有参的构造方法
           * */
           this(10);
       }
   
       public CirQueue(int size){
           queue=new Object[size];
           front=0;
           rear=0;
       }
   
       /*
       * 入队
       * */
       public boolean enter(Object o){
           if((rear+1)%queue.length==front){
               System.out.println("队列已满!");
               return false;
           }
   
           queue[rear]=o;
           rear=(rear+1)%queue.length;
           return true;
   
       }
   
       /*
       * 出队
       * */
       public Object depaeure(){
           if (rear==front){
               return null;
           }
           Object o=queue[front];
           front=(front+1)%queue.length;
           return o;
       }
   
   
       public static void main(String[] args)throws Exception{
           CirQueue cirQueue=new CirQueue(5);
           cirQueue.enter("张三");
           cirQueue.enter("李四");
           cirQueue.enter("王五");
           cirQueue.enter("赵六");
           //当这里入队时，最后的位置为空，队列已满
           cirQueue.enter("孙七");
   
   
           for (int i = 0; i <5 ; i++) {
   
               System.out.println("出队元素为："+cirQueue.depaeure());
           }
       }
   }