#include<iostream>
#include<cstdlib>
using namespace std;

队列:只可以单向举办出栈风流罗曼蒂克端实行进栈。

/*
     用数组达成队列,front指向对头,rear指向队尾。初步时 
front等于rear等于0
     进队产生在队尾,然后rear+1;
     出队发生在投机,然后front+1;
    
     front                                   rear  
       a    b  c  d   e   f    g   h  i   j    k
    
     如上所示,若要实行进队操作,插入 l  
     front                                          rear  
       a    b  c  d   e   f    g   h  i   j    k     l
       
     若要出队操作
           front                                          rear  
       a    b     c     d   e   f    g   h  i   j    k     l
    把 a 进行输出,然后将front+1,指向了 b 地点。
    因为是用数组达成,所以不可能对单身对 a
进行释放操作,但我们得以将front+1
    再把该队列忽视掉 a
,这只是人为忽略,但a依旧存在。那样大家就能够队列看出
          front                                          rear  
            b     c     d   e   f    g   h  i   j    k     l
      
    
*/
#include<stdio.h>
#include<stdlib.h>
int input(int *,int len);//入队
void output(int *,int len); //出队

typedef struct Queue
{
int *Array;
int Front,Rear;
}*MyQueue;

队首:只同意开展出栈操作,能够举办删除。

//达成那八个函数
int input(int *p,int len)
{
   //len为数组的长度
   int num=0;//用于收纳多少个数字
   int num2=0;
   //int front=0;//队头
   int rear=0;//队尾
   printf(“请问您要输入多少个数字:\金沙国际官网,n”);
   scanf(“%d”,&num);
   while(num<0||num>len)
   {
         system(“cls”);
         printf(“你输入的数额不符合,在0-%d内,请重新输入:”,lenState of Qatar;
         scanf(“%d”,&num);
   }
   for(rear;rear<num;rear++)
   {
          system(“cls”);
          printf(“您要输入的数字:”卡塔尔;
          scanf(“%d”,&num2);
          p[rear]=num2;     
   }
   if(rear==num)
   {
          system(“cls”);
       printf(“输入落成\n”);
       printf(“大器晚成共输入了第%d个数:\n”,rear);    
   }
   return num;
}
void output(int *p,int len)
{
    int front=0;//队头
    int num=1;//用于循环,况且和len相比
    for(num;num<=len;num++)
    {
        //system(“cls”);
        printf(“出游列的是:%d\n”,p[front]);//出队
        front++;    
    }
}
int main()
{
    int n1=0;//用于吸收接纳input函数的重返值
    int data[10];
    n1=input(data,10);
    output(data,n1);
    //delete data;
    //system(“cls”);
    n1=input(data,10);
    output(data,n1);
    return 0;
 }

MyQueue Create(voidState of Qatar;    //创设二个队列 
int IsEmpty(MyQueue QState of Qatar;  //核算是还是不是为空栈 
void DeQueue(MyQueue Q); //出队 
void EnQueue(int X,MyQueue Q); //入队 
void GetQueueFront(MyQueue Q卡塔尔(قطر‎; //获取队头成分 
void GetQueueRear(MyQueue QState of Qatar;  //获取队尾成分 

队尾:只允许开展入栈操作,能够开展插队。

int main()  //测试 
{
MyQueue Q=Create();
EnQueue(100,Q);
DeQueue(Q);
return 0;
}

队尾进,队尾出,先进先出。

int IsEmpty(MyQueue Q)
{
return Q->Front==Q->Rear;  
//假若队头下标等于队尾下标,也等于空队列那么重回1,不然重临0 
}

由此队列的落成也会有二种方式,风姿洒脱种是数组完结队列,黄金时代种是用链表完成队列。

void EnQueue(int X,MyQueue Q)
{
if(Q->Front==Q->Rear&&Q->Rear==0卡塔尔国  //假诺是空队列 
{
Q->Array[Q->Front]=X;     //从底部入列
Q->Array[Q->Rear]=Q->Array[Q->Front];    
//空队列入队的话,队头也是队尾 
cout <<Q->Array[Q->Front] <<“已入列”
<<“入队后” ;
}
else        //要是或不是空队列 
{
Q->Array[++Q->Rear]=X; //从尾巴部分入列 
cout <<X <<“已入列” <<endl <<“入队后 ” ;  
 //提示 
}
GetQueueFront(Q);
GetQueueRear(Q);
cout <<endl ; 
}

金沙国际官网 1

void DeQueue(MyQueue Q)         
{
if(IsEmpty(Q))
   cout <<“队列为空不可能出列 ” <<endl ;      
//即使是空队列无法出列 
else
   {
    Q->Array[Q->Front]=Q->Array[Q->Front++];
 //队头以后八个因素挪 
}
cout <<“出队后” ;     //提示 
GetQueueFront(Q);
GetQueueRear(Q);
}

第一是用数组来兑现队列。

MyQueue Create(void)
{
MyQueue Q;
Q->Front=Q->Rear=0;   //起初化队列 
int a[8]={18,19,11,13,25,26,30,14};
for(int i=0;i<8;i++)
{
if(i==0卡塔尔(قطر‎   //风流倜傥最初的先入队头 
{
Q->Array[Q->Front]=a[i];
Q->Array[Q->Rear]=Q->Array[Q->Front];
 //意气风发上马队尾也是队头 
cout <<Q->Array[Q->Rear]<<“已入列 ” <<endl ;
 //提示 
}
else        //有了队头后就从队尾入队 
   {
Q->Array[++Q->Rear]=a[i]; //从尾部入列 
    cout <<Q->Array[Q->Rear]<<“已入列 ” <<endl
;//提示 
}
}
cout <<endl ;
GetQueueFront(Q);
GetQueueRear(Q);
cout <<endl ;
return Q;
}

动用数组成代表队列,因为在剔除时front会十分的大,所以最终会现出生龙活虎种还应该有空间可是却显得无空间的情景。

void GetQueueFront(MyQueue Q)
{
if(IsEmpty(Q))
   cout <<“空队列!” <<endl ;
else
   cout <<Q->Array[Q->Front] <<“为队头 ”
<<endl ; //Front便是队头 
}

解决方法:

void GetQueueRear(MyQueue Q)
{
if(IsEmpty(Q))
   cout <<“空队列!” <<endl ;
else
   cout <<Q->Array[Q->Rear] <<“为队尾 ” <<endl
; //Rear正是队尾 
}

营造循环队列,算法为:

决断是不是队满:(rear+1State of Qatar%a.length==front 
//假设相等的话则证实队列已满

rear=(rear+1卡塔尔国%a.length;       //成立循环

兑今世码:

 1     public class Queue {  
 2         private static final int defaultSize = 10;  
 3         private Node[] a;  
 4         private int rear;  
 5         private int front;  
 6         Queue(){                //默认构造方法  
 7             a = new Node[10];  
 8             rear = 0;  
 9             front = 0;  
10         }  
11         Queue(int n){           //指定队列长度的构造方法  
12             a = new Node[n];  
13             rear = 0;  
14             front = 0;  
15         }  
16         public boolean add(Node node){          //在队尾增加队列节点  
17             if((rear+1) % a.length == front )       //检测该对列是否已经满了  
18                 return false;  
19             else{  
20                 a[rear] = node;  
21                 rear = (rear+1) % a.length;     //构建循环队列      
22                 return true;  
23             }     
24         }  
25         public Node remove(){                   //删除对首节点  
26             if(rear == front)  
27                 return null;  
28             else{  
29                 Node n = a[front];  
30                 front = (front+1) % a.length;  
31                 return n;  
32             }     
33         }  
34         public boolean isEmpty(){               //检测是否为空  
35             if(rear == front)  
36                 return true;  
37             else   
38                 return false;  
39         }  
40         public int size(){              //返回队列长度  
41             return a.length;  
42         }  
43     }  

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图