队列是一种特殊的线性表,它只允许在表的前端(front)进行删除操作,只允许在表的后端(rear)进行插入操作。
1.队列的顺序存储结构及实现
2.循环队列(顺序结构存储实现)
3.队列的链式存储结构及实现
1.队列的顺序存储结构及实现
- publicclassSequenceQueue<T>
- {
- privateintDEFAULT_SIZE=10;
- //保存数组的长度。
- privateintcapacity;
- //定义一个数组用于保存顺序队列的元素
- privateObject[]elementData;
- //保存顺序队列中元素的当前个数
- privateintfront=0;
- privateintrear=0;
- //以默认数组长度创建空顺序队列
- publicSequenceQueue()
- {
- capacity=DEFAULT_SIZE;
- elementData=newObject[capacity];
- }
- //以一个初始化元素来创建顺序队列
- publicSequenceQueue(Telement)
- {
- this();
- elementData[0]=element;
- rear++;
- }
- /**
- *以指定长度的数组来创建顺序队列
- *@paramelement指定顺序队列中第一个元素
- *@paraminitSize指定顺序队列底层数组的长度
- */
- publicSequenceQueue(Telement,intinitSize)
- {
- this.capacity=initSize;
- elementData=newObject[capacity];
- elementData[0]=element;
- rear++;
- }
- //获取顺序队列的大小
- publicintlength()
- {
- returnrear-front;
- }
- //插入队列
- publicvoidadd(Telement)
- {
- if(rear>capacity-1)
- {
- thrownewIndexOutOfBoundsException("队列已满的异常");
- }
- elementData[rear++]=element;
- }
- //移除队列
- publicTremove()
- {
- if(empty())
- {
- thrownewIndexOutOfBoundsException("空队列异常");
- }
- //保留队列的rear端的元素的值
- ToldValue=(T)elementData[front];
- //释放队列的rear端的元素
- elementData[front++]=null;
- returnoldValue;
- }
- //返回队列顶元素,但不删除队列顶元素
- publicTelement()
- {
- if(empty())
- {
- thrownewIndexOutOfBoundsException("空队列异常");
- }
- return(T)elementData[front];
- }
- //判断顺序队列是否为空队列
- publicbooleanempty()
- {
- returnrear==front;
- }
- //清空顺序队列
- publicvoidclear()
- {
- //将底层数组所有元素赋为null
- Arrays.fill(elementData,null);
- front=0;
- rear=0;
- }
- publicStringtoString()
- {
- if(empty())
- {
- return"[]";
- }
- else
- {
- StringBuildersb=newStringBuilder("[");
- for(inti=front;i<rear;i++)
- {
- sb.append(elementData[i].toString()+",");
- }
- intlen=sb.length();
- returnsb.delete(len-2,len).append("]").toString();
- }
- }
- }
2.循环队列(顺序结构存储实现)
- importjava.util.Arrays;
- publicclassLoopQueue<T>
- {
- privateintDEFAULT_SIZE=10;
- //保存数组的长度。
- privateintcapacity;
- //定义一个数组用于保存循环队列的元素
- privateObject[]elementData;
- //保存循环队列中元素的当前个数
- privateintfront=0;
- privateintrear=0;
- //以默认数组长度创建空循环队列
- publicLoopQueue()
- {
- capacity=DEFAULT_SIZE;
- elementData=newObject[capacity];
- }
- //以一个初始化元素来创建循环队列
- publicLoopQueue(Telement)
- {
- this();
- elementData[0]=element;
- rear++;
- }
- /**
- *以指定长度的数组来创建循环队列
- *@paramelement指定循环队列中第一个元素
- *@paraminitSize指定循环队列底层数组的长度
- */
- publicLoopQueue(Telement,intinitSize)
- {
- this.capacity=initSize;
- elementData=newObject[capacity];
- elementData[0]=element;
- rear++;
- }
- //获取循环队列的大小
- publicintlength()
- {
- if(empty())
- {
- return0;
- }
- returnrear>front?rear-front
- :capacity-(front-rear);
- }
- //插入队列
- publicvoidadd(Telement)
- {
- if(rear==front
- &&elementData[front]!=null)
- {
- thrownewIndexOutOfBoundsException("队列已满的异常");
- }
- elementData[rear++]=element;
- //如果rear已经到头,那就转头
- rear=rear==capacity?0:rear;
- }
- //移除队列
- publicTremove()
- {
- if(empty())
- {
- thrownewIndexOutOfBoundsException("空队列异常");
- }
- //保留队列的rear端的元素的值
- ToldValue=(T)elementData[front];
- //释放队列的rear端的元素
- elementData[front++]=null;
- //如果front已经到头,那就转头
- front=front==capacity?0:front;
- returnoldValue;
- }
- //返回队列顶元素,但不删除队列顶元素
- publicTelement()
- {
- if(empty())
- {
- thrownewIndexOutOfBoundsException("空队列异常");
- }
- return(T)elementData[front];
- }
- //判断循环队列是否为空队列
- publicbooleanempty()
- {
- //rear==front且rear处的元素为null
- returnrear==front
- &&elementData[rear]==null;
- }
- //清空循环队列
- publicvoidclear()
- {
- //将底层数组所有元素赋为null
- Arrays.fill(elementData,null);
- front=0;
- rear=0;
- }
- publicStringtoString()
- {
- if(empty())
- {
- return"[]";
- }
- else
- {
- //如果front<rear,有效元素就是front到rear之间的元素
- if(front<rear)
- {
- StringBuildersb=newStringBuilder("[");
- for(inti=front;i<rear;i++)
- {
- sb.append(elementData[i].toString()+",");
- }
- intlen=sb.length();
- returnsb.delete(len-2,len).append("]").toString();
- }
- //如果front>=rear,有效元素为front->capacity之间、0->front之间的
- else
- {
- StringBuildersb=newStringBuilder("[");
- for(inti=front;i<capacity;i++)
- {
- sb.append(elementData[i].toString()+",");
- }
- for(inti=0;i<rear;i++)
- {
- sb.append(elementData[i].toString()+",");
- }
- intlen=sb.length();
- returnsb.delete(len-2,len).append("]").toString();
- }
- }
- }
- }
3.队列的链式存储结构及实现
- publicclassLinkQueue<T>
- {
- //定义一个内部类Node,Node实例代表链队列的节点。
- privateclassNode
- {
- //保存节点的数据
- privateTdata;
- //指向下个节点的引用
- privateNodenext;
- //无参数的构造器
- publicNode()
- {
- }
- //初始化全部属性的构造器
- publicNode(Tdata,Nodenext)
- {
- this.data=data;
- this.next=next;
- }
- }
- //保存该链队列的头节点
- privateNodefront;
- //保存该链队列的尾节点
- privateNoderear;
- //保存该链队列中已包含的节点数
- privateintsize;
- //创建空链队列
- publicLinkQueue()
- {
- //空链队列,front和rear都是null
- front=null;
- rear=null;
- }
- //以指定数据元素来创建链队列,该链队列只有一个元素
- publicLinkQueue(Telement)
- {
- front=newNode(element,null);
- //只有一个节点,front、rear都指向该节点
- rear=front;
- size++;
- }
- //返回链队列的长度
- publicintlength()
- {
- returnsize;
- }
- //将新元素加入队列
- publicvoidadd(Telement)
- {
- //如果该链队列还是空链队列
- if(front==null)
- {
- front=newNode(element,null);
- //只有一个节点,front、rear都指向该节点
- rear=front;
- }
- else
- {
- //创建新节点
- NodenewNode=newNode(element,null);
- //让尾节点的next指向新增的节点
- rear.next=newNode;
- //以新节点作为新的尾节点
- rear=newNode;
- }
- size++;
- }
- //删除队列front端的元素
- publicTremove()
- {
- NodeoldFront=front;
- front=front.next;
- oldFront.next=null;
- size--;
- returnoldFront.data;
- }
- //访问链式队列中最后一个元素
- publicTelement()
- {
- returnrear.data;
- }
- //判断链式队列是否为空队列
- publicbooleanempty()
- {
- returnsize==0;
- }
- //清空链队列
- publicvoidclear()
- {
- //将front、rear两个节点赋为null
- front=null;
- rear=null;
- size=0;
- }
- publicStringtoString()
- {
- //链队列为空链队列时
- if(empty())
- {
- return"[]";
- }
- else
- {
- StringBuildersb=newStringBuilder("[");
- for(Nodecurrent=front;current!=null
- ;current=current.next)
- {
- sb.append(current.data.toString()+",");
- }
- intlen=sb.length();
- returnsb.delete(len-2,len).append("]").toString();
- }
- }
- }