① java循環對列怎麼跳著出隊
沒明白什麼意思，是隊列中的元素，隔一個出隊列嗎？這樣的話可以用兩個隊列，對象先裝進一個隊列A，之後for遍歷的時候 奇數項 拿出來 ，偶數項 放入另一個隊列B，第一個隊列A遍歷完，將隊列A當成隊列B 隊列B當成隊列A，重復以上。其他間隔也可以自己寫方法。
② 用java實現循環隊列
簡單寫了下，希望你能看明白
import java.util.ArrayList;
public class SeqQueue {
ArrayList<String> list;
public SeqQueue() {
list = new ArrayList<String>();
}
public String getFirst() {
if (!list.isEmpty()) {
String s = list.get(0);
list.remove(0);
return s;
}
return null;
}
public void insertLast(String s) {
list.add(s);
}
public static void main(String[] args) {
SeqQueue seq = new SeqQueue();
seq.insertLast("111");
seq.insertLast("222");
seq.insertLast("333");
System.out.println(seq.getFirst());
System.out.println(seq.getFirst());
System.out.println(seq.getFirst());
}
}
③ 用java語言設計順序循環隊列類
代碼如下：
importjava.io.Serializable;
importjava.util.Arrays;
publicclassLoopQueue<T>implementsSerializable{
/**
*@FieldsserialVersionUID:TODO
*/
=-3670496550272478781L;
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++;
}
//獲取循環隊列的大小
publicintsize(){
if(isEmpty()){
return0;
}
returnrear>front?rear-front:capacity-(front-rear);
}
//插入隊列
publicvoidadd(Telement){
if(rear==front&&elementData[front]!=null){
("隊列已滿的異常");
}
elementData[rear++]=element;
//如果rear已經到頭，那就轉頭
rear=rear==capacity?0:rear;
}
//移除隊列
publicTremove(){
if(isEmpty()){
("空隊列異常");
}
//保留隊列的rear端的元素的值
ToldValue=(T)elementData[front];
//釋放隊列的rear端的元素
elementData[front++]=null;
//如果front已經到頭，那就轉頭
front=front==capacity?0:front;
returnoldValue;
}
//返回隊列頂元素，但不刪除隊列頂元素
publicTelement(){
if(isEmpty()){
("空隊列異常");
}
return(T)elementData[front];
}
//判斷循環隊列是否為空隊列
publicbooleanisEmpty(){
//rear==front且rear處的元素為null
returnrear==front&&elementData[rear]==null;
}
//清空循環隊列
publicvoidclear(){
//將底層數組所有元素賦為null
Arrays.fill(elementData,null);
front=0;
rear=0;
}
publicStringtoString(){
if(isEmpty()){
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();
}
}
}
publicstaticvoidmain(String[]args){
LoopQueue<String>queue=newLoopQueue<String>("aaaa",3);
//添加兩個元素
queue.add("bbbb");
queue.add("cccc");
//此時隊列已滿
System.out.println(queue);
//刪除一個元素後，隊列可以再多加一個元素
queue.remove();
System.out.println("刪除一個元素後的隊列："+queue);
//再次添加一個元素，此時隊列又滿
queue.add("dddd");
System.out.println(queue);
System.out.println("隊列滿時的長度："+queue.size());
//刪除一個元素後，隊列可以再多加一個元素
queue.remove();
//再次加入一個元素，此時隊列又滿
queue.add("eeee");
System.out.println(queue);
}
}
④ Java如何實現一個循環隊列保存另一個類的對象
這里說下我的思路。循環隊列。首先你要想清楚隊列。隊列有多種實現方式。鏈表和數組。
如果是固定的個數那可以用數組實現否則用雙向循環鏈表實現。 具體說實現方式可以參考link list或arrayDequeue
⑤ java中的arraydeque是循環隊列嗎
ArrayDeque的實現Java中的雙端隊列是用數組實現的，是循環隊列。
⑥ Java如何使用數組實現循環隊列的案例
class Element{
int id;
String name;
Element(int a,String n){
id=a;name=n;
}
}
class SeqQueue{
int first,last,maxsize;
Element queue[];
SeqQueue(int i){
maxsize=i;
first=last=-1;
queue=new Element[i];
}
public void clear(){//置空
first=last=-1;
}
public boolean isEmpty(){//判空
if(first==-1)return true;
else return false;
}
public Element getFirst(){//取隊列頭元素
if(first==-1)return null;
else return queue[first+1];
}
public boolean isFull(){//判滿
if((last+1)%maxsize==first)return true;
else return false;
}
public boolean enQueue(Element e){//入隊
if(this.isFull())return false;
if(this.isEmpty())
first=last=0;
else
last=(last+1)%maxsize;
queue[last]=e;
return true;
}
public Element deQueue(){//出隊
Element t=queue[first];
if(this.isEmpty())return null;
if(first==last){
queue[first]=null;
this.clear();
return t;
}
queue[first]=null;
first=(first+1)%maxsize;
return t;
}
public int getLength(){//隊列長度
if(last>=first)return last-first+1;
else return maxsize-(first-last)+1;
}
public void display(){//列印所有元素
int i,j;
for (i=first,j=0;j<this.getLength();i=(i+1)%maxsize,j++)
System.out.println(queue[i].id);
}
}
⑦ java中，實現一個循環隊列，其中的邊界條件有些弄不明白，請看我的代碼：
//我做了一個測試類，你運行一下試試吧
//問題的關鍵在於這個類的設計似乎是，假設size是3，但是數組的size是4
//putloc是0,但是put的位置在數組中是1
//總覺得這個類的設計很怪，既然size是3，底層實現也做成3就好了。
import java.util.Arrays;
public class CircularQueue {
private char q[];
private int putloc, getloc;
public static void main(String[] args) {
CircularQueue circularQueue = new CircularQueue(3);
circularQueue.put('1');
circularQueue.put('1');
circularQueue.put('1');
circularQueue.put('1');
}
private void paint(String s) {
System.out.println(s + ": putloc=" + putloc + " getloc=" + getloc + " "
+ Arrays.toString(q));
}
public CircularQueue(int size) {
q = new char[size + 1];// 注意：這里數組長度加 1。
putloc = getloc = 0;
paint("create!");
System.out.println();
}
public void put(char ch) {
paint("before put");
if (putloc + 1 == getloc | ((putloc == q.length - 1) & (getloc == 0))) { // 第一個邊界條件想不清楚，為什麼putloc+1==getloc
System.out.println("--Queue is full.");
return;
}
putloc++;
if (putloc == q.length)
putloc = 0;
q[putloc] = ch;
paint("after put");
System.out.println();
}
public char get() {
paint("before get");
if (getloc == putloc) {
System.out.println("--Queue is empty.");
return (char) 0;
}
getloc++;
if (getloc == q.length)
getloc = 0;
paint("after get");
System.out.println();
return q[getloc];
}
}
⑧ java環形隊列
根據java環形隊列問題編寫的程序如下：
import java.util.ArrayList;
import java.util.List;
public class F {
static boolean isPrime(int a){
int i;
for(i=2;i<a;i++){
if(a%i==0){
break;
}
}
if(i==a){
return true;
}else{
return false;
}
}
public static void main(String[] args) {
List l=new ArrayList();
for(int i=2;i<=300;i++){
if (isPrime(i)){
l.add(i);
}
}
List m=new ArrayList();
for(int i=0;i<l.size();i++){
m.add(l.get(i));
}
int point=0,number=1;
while(l.size()>1){
if(number%3==0){
l.remove(point);
--point;
}
++point;
++number;
if(point>l.size()-1){
point=0;
}
}
int position=m.indexOf(l.get(0));
System.out.println("最後剩下的數為："+l.get(0));
System.out.println("它的編號為： "+(position+1));
}
}
運行結果：
最後剩下的數為：211
它的編號為： 47
⑨ java裡面，說到循環隊列的存儲空間為Q(1:35)包含什麼含義，如果front=1，front=
如果是正數就不用加35了，如果是負數才要加35
這一題明顯是個小陷阱，開始時候front=rear ，結束了還是front=rear 說明進來的和出去的一樣多啊，你看 如果這是進來一個元素rear就加1，變成rear=1（因為是1：35啊，就是說元素只能排在1-35之間，35排完了就滿了嗎，沒有 35排完了如果再進來元素就該排在1的位置上了。而不是36，這你得明白）
好了 進來一個rear加1 出去一個呢，front加1 就這樣進來出去，進來出去，到最後front和rear還是相等的，那不就說明進來和出去的一樣多嘛。 這樣一來最後的元素就和原來的元素一樣多了，明顯不是0就是35，因為要麼隊空（0個元素），要麼隊滿（35個元素）
%是求余數用的 10%3=1，就是這個意思 那個公式就是純粹數學公式，和編程，語言都沒關系。
這種題你畫一張圖最好理解了，當然短一點最好，弄個隊列長度為6的，自己動動手，出對入隊的畫畫就全明白了