java数据结构--队列

1. 用链表实现单向队列

package com.jzm.stackQueueTree;
public class LinkQueue<T>{   //链表实现单向队列

	 private Node firstNode;
	 private Node lastNode;	 
	 
	 public LinkQueue(){	    
		 firstNode = null;
		 lastNode = null;		 
	 }//end constructor
	 
	 private class Node{		 //内部节点 
		     private  T data;
		     private  Node next;			 		 
			 private  Node(T data){
		  		  this.data = data;
		  		  this.next = null;			 
		  	 }//end constructor
			 
			 private  T getData(){			  
				 return data;			 
			 }
		 
			  private Node getNextNode(){			 
				  return next;
			 }		
			  
	         private  void  setNextNode(Node n){
				      this.next =  n;					      
			 }	 
	 }//end class Node
	 
		
    private  boolean isEmpty(){		 
			
        return  firstNode == null;  
	}//end isEmpty 判断是否为空
		 
	 public void enqueue(T newEntry){
		
	  Node newNode = new Node(newEntry);
	  
	  if (isEmpty()){		

		  firstNode = newNode;
		  lastNode  = newNode;
	 }else{
	     lastNode.setNextNode(newNode);
	     lastNode = newNode;	 
	  }		 	 
     } //end enqueue 从队尾加入新元素
	 
	 
	 
	 public T getFront(){  //检索前端元素	 
		 T front = null;		 
		 if(!isEmpty())		  
			 front = firstNode.data;
		 return front;		 
	 }//从队列前端取元素
	  
	 
	 
	 public T deletequeue(){
		 T front = null;
		 if (!isEmpty()){		
			 front = firstNode.getData();
			 firstNode = firstNode.getNextNode();		
		  }
		 
		 if (firstNode ==null) { //如果只有一个元素，删除了为空的话，尾节点应该也为空
			  lastNode = null;
		 }
		   return front;
	 }	//end deletequeue
	 
	 
	 public void clear(){
		 firstNode = null;
		 lastNode = null;		  		  
	 } //end clear 
	 
	 public void display(){
		 
		 if(isEmpty()){
			 System.out.println("队列为空");
		 }else {
			Node point = firstNode;
			while (point != null) {
			    System.out.println(point.getData());
				point = point.getNextNode();  
			}			 
		}	 
	 }	 
	 
	 public static void main(String[] args) {	   
		       LinkQueue<Integer> linkQueue = new LinkQueue<Integer>();	   
		       linkQueue.enqueue(1);
		       linkQueue.enqueue(2);
		       linkQueue.enqueue(3);	
		       linkQueue.display();
		       linkQueue.deletequeue();
		       linkQueue.deletequeue();
		       linkQueue.deletequeue();
		       linkQueue.display();
	 } 
}

2.   用数组实现队列

 

package com.jzm.stackQueueTree;

public class ArrayQueue<T> {  
   /**
    * 用可变数组，实现循环队列
    */
	 private T [] queue;
	 private int frontIndex;
	 private int backIndex;
	 private static  final  int  maxsize = 3;  //可以容纳的大小	 
	 
	 public ArrayQueue(){	 
		 queue = (T[])new Object[maxsize];
		 frontIndex = -1;
		 backIndex =  -1;		 
	 }  
	 
	 
	 public ArrayQueue(int  initsize){		 
		 queue = (T[]) new Object[initsize+1];
		 frontIndex = -1;
		 backIndex =  -1;	 
	 }	//end constructor 
	
	 
	 private boolean isEmpty(){		 		
		  return ((frontIndex+backIndex==-2) && frontIndex==(backIndex%queue.length));
	 }// 判断队列是否为空   
		 
	 private boolean isArrayFull(){	 
		 
		  return  frontIndex == ((backIndex+1)%queue.length); 
		  
	 }//end full 判断数组是否满
	   
	 public void enqueue(T newEntry){		 
		  if(isEmpty()){
			   System.out.println("为空此时frontIndex="+frontIndex);
			   System.out.println("为空此时backIndex="+backIndex);
			   frontIndex = (frontIndex+1)% queue.length;	
			   queue[frontIndex] = newEntry;			   
			   backIndex = (backIndex+1)%queue.length;			   		   
		  }else{				 
		     if (isArrayFull()) {
			  System.out.println("加入"+newEntry+"时，队列已经满，等待分配");
			  System.out.println("满此时frontIndex="+frontIndex);
			  System.out.println("满此时backIndex="+backIndex);		    		  
			  doubleArray();
	         }	     		     
		      backIndex = (backIndex+1)%queue.length;	  
		      queue[backIndex] = newEntry;	
		  }
	 }  //end enqueue	 
	 
	 public T getFront(){
		 T front = null;
		 if (!isEmpty()) {
			 front = queue[frontIndex];
		 }  		 
		 return front;
	 }//end getFront  得到队列头结点
	 
	 
	 public T  deletequeue(){
		  T  front  = null;
		  if (!isEmpty()) {
			front = queue[frontIndex];
			queue[frontIndex] = null;
			frontIndex = (frontIndex+1)%queue.length;			
		 }//end if		  
		  return front;		 
	 }//end deletequeue;删除队列头结点
	 
	 
	 public void doubleArray(){		 
		 T [] oldQueue =  queue;
		 int  oldsize =    queue.length;	
		 
		 System.out.println("oldsize=" + oldsize);			 
		 queue = (T[])new Object[2 * oldsize];			 
		 for(int i=0;i<oldsize;i++){
			  queue[i] = oldQueue[frontIndex];
			  frontIndex = (frontIndex+1)%oldsize;		 			 
		 }//end for
		 frontIndex= 0;
		 backIndex = oldsize-1;	   		 
	 }// end doubleArray
	 
	 public void  display(){	 
		 if (frontIndex < backIndex){ //说明没有循环			 		  
		  for(int i=frontIndex; i<=backIndex; i++)	           
			  System.out.println(queue[i]);
		 }else{   			  
		 	 for (int i = frontIndex; i < queue.length; i++) {
				  System.out.println(queue[i]);
			 }   		 	 
		 	 for (int i = 0; i <=backIndex;i++) {
		 		  System.out.println(queue[i]);
			}			  
	  }
	 }  //输出队列的值
	 
	 public static void main(String[] args) {	   
		     ArrayQueue<Integer> arrayQueue = new ArrayQueue<Integer>();
		     arrayQueue.enqueue(1);
		     arrayQueue.enqueue(2);		     
		     arrayQueue.enqueue(3);
		     arrayQueue.enqueue(4);
		     arrayQueue.enqueue(5);
		     arrayQueue.enqueue(6);
		     arrayQueue.enqueue(7);
		     arrayQueue.deletequeue();
		     arrayQueue.deletequeue();
		     arrayQueue.enqueue(8);		     
		     System.out.println("------------------");
		     arrayQueue.display();		     
	 } 	 
}