数据结构 队列

队列是一个线性表，其插入和删除分别在表的不同端进行。插入元素的那一端称为队尾，删除元素的那一端称为队首。简言之队列就是一个先进先出的数据结构，是程序设计中常用的数据结构。下面使用java分别封装数组描述和链表描述的队列。

1、队列的操作：

插入：队列的插入只能插入队尾。

删除：队列的删除只能在队首进行。

大小：返回队列的大小。

返回队首：队列是排队存储数据，因此必需含有取出数据，它的取出数据只能在队首进行。

复制：

是否为空：

2、数组描述的队列

数组描述队列分别使用一个指针表示队尾，另一个指针表示队首。但使用常常是动态添加的，当添加的数量大于数组大小需要建立一个更大的数组，这里将数组增加两倍。下面是java使用数组描述的队列：

package Structure;

public class ArrayQueue {
	 private Object [] queue;//存储元素的数组
	 private int first;//头指针
	 private int last;//尾指针
	 private int size;//队列的大小
	 
	 //无参构造函数，初始化一个4个元素的空数组
	 public ArrayQueue (){
		 queue =new Object [4];
		 first =0;
		 last =0;
		 size=0;
	 }
	 
	 //复制构造函数
	 public ArrayQueue(ArrayQueue q){
		 if(q.size()!=0){
			 first=0;
			 last=size=q.size();
			 queue=new Object[size+1];
			 for(int i=0;i<size;i++)
				 queue[i]=q.pop();
		 }
		 else{
			 queue =new Object [4];
			 first =0;
			 last =0;
			 size=0;
		 }
		 
	 }
	 
	 //私有增加数组函数
	 private void addSize(){
		 Object [] temp =new Object [size*2];
		 int i=first;
		 int j=0;
		 temp[j]=queue[i];
		 	i=(i+1)%size;
		 	j++;
		 while(i!=last){
			temp[j]=queue[i];
		 	i=(i+1)%size;
		 	j++;
		 }
		 first=0;
		 last=size;
		 queue=temp;
	 }
	 
	 //大小函数
	 public int size(){
		 return size;
	 }
	 
	 //插入函数
	 public void insert(Object theElement){
		 if(size==queue.length)
			 addSize();
		 
		 queue[last]=theElement;
		 last=(last+1)%queue.length;
		 size++;
	 }
	 
	 //删除函数
	 public Object pop(){
		 if(size==0)
			 return null;
		 Object popElement=queue[first];
		 first=(first+1)%(queue.length);
		 size--;
		 return popElement;
	 }
	 
	 //队首元素
	 public Object getTop(){
		 if(size==0)
			 return null;
					 
		 return queue[first];
	 }
	 
	 //打印队列所有元素
	 public String toString(){
		 if (size==0)
			 return null;
		 
		 String str="";
		 int i=first;
		 str+=queue[i]+" ";
		 i=(i+1)%queue.length;
		 
		 while(i!=last){
			 str+=queue[i]+" ";
			 i=(i+1)%queue.length;
		 }
		 
		 return str;
	 }
}

测试代码

package Test;

import Structure.ArrayQueue;

public class ArrayQueueTest {

	public static void main(String[] args) {
		ArrayQueue queue =new ArrayQueue();
		
		//插入和删除
		queue.insert(1);
		queue.insert(2);
		queue.insert(3);
		queue.insert(4);
		queue.pop();
		queue.pop();
		queue.insert(5);
		queue.insert(6);
		queue.insert(7);
		
		//打印整个队列
		System.out.println("队列内容是："+queue);
		//队列大小
		System.out.println("队列大小是："+queue.size());
		//取队列首元素
		System.out.println("当前队列首内容是："+queue.getTop());
		
		//使用复制构造函数
		ArrayQueue queue1=new ArrayQueue(queue);
		System.out.println("队列内容是："+queue1);
		

	}

}

输出：

队列内容是：3 4 5 6 7 
队列大小是：5
当前队列首内容是：3
队列内容是：3 4 5 6 7 

3、链表描述的队列：

链表描述的插入和删除相对于数组描述的队列更加直观和高效，只需要确定链表的头是队列的头还是尾，就可以在链表的两端进行插入和删除。下面是java使用链表描述的队列包括节点的声明：

package Structure;

public class Node {	//定义节点
	Object element;	//节点元素
	Node next;	//节点指针
	
	//无参构造函数
	public Node(){
		element=null;
		next=null;
	}
	
	//单值构造函数,用于末尾插入
	public Node(Object theElement){
		element=theElement;
		next=null;
	}
	
	//双值构造函数，用于中间插入。
	public Node(Object theElement,Node node){
		element=theElement;
		next=node;
	}
}

队列类：

package Structure;

public class LinkQueue {

	private Node root;//队列的头节点
	
	//无参构造函数，构建空队列
	public LinkQueue(){
		root=null;
	}
	
	//复制构造函数
	public LinkQueue(LinkQueue q){
		Node p=q.getRoot();
		if(p==null){
			root=null;
			return;
		}	
		root =new Node(p.element);
		Node node=root;
		while(p.next!=null){
			p=p.next;
			node.next=new Node(p.element);
			node=node.next;
		}
			
	}
	
	//私有返回根节点
	private Node getRoot(){
		return root;
	}
	
	//插入函数
	public void insert(Object theElement){
		if(root==null)
			root=new Node(theElement);
		else{
			Node node=root;
			while(node.next!=null){
				node=node.next;
			}
			node.next=new Node(theElement);
		}
	}
	
	//队列的长度
	public int size(){
		if(root==null)
			return 0;
		else{
			Node node=root;
			int size=1;
			while(node.next!=null){
				node=node.next;
				size++;
			}
			return size;
		}
	}
	
	//删除函数
	public Object pop(){
		if(root==null)
			return null;
		
		Object theElement=root.element;
		root=root.next;		
		return theElement;
	}
	
	//取队列首元素
	public Object getTop(){
		return root.element;
	}
	
	//打印队列元素
	public String toString(){
		String str="";
		if (root==null)
			;
		else{
			str+=root.element+" ";
			Node node=root;
			while(node.next!=null){
				node=node.next;
				str+=node.element+" ";
			}
		}
		return str;
	}
	
}

测试代码：

package Test;

import Structure.ArrayQueue;
import Structure.LinkQueue;

public class LinkQueueTest {

	public static void main(String[] args) {
		//实例化
		LinkQueue queue=new LinkQueue();
		
		//插入和删除
		queue.insert(1);
		queue.insert(2);
		queue.insert(3);
		queue.insert(4);
		queue.pop();
		queue.pop();
		queue.insert(5);
		queue.insert(6);
		queue.insert(7);
		//打印整个队列
		System.out.println("队列内容是："+queue);
		//队列大小
		System.out.println("队列大小是："+queue.size());
		//取队列首元素
		System.out.println("当前队列首内容是："+queue.getTop());
		
		//使用复制构造函数
		LinkQueue queue1=new LinkQueue(queue);
		System.out.println("队列内容是："+queue1);

	}

}

输出：

队列内容是：3 4 5 6 7 
队列大小是：5
当前队列首内容是：3
队列内容是：3 4 5 6 7