精华内容
下载资源
问答
  • #include"stdio.h"#include"stdlib.h"//这是一个静态队列的例程#define MAXSIZE 10 //队列的最大容量typedef char ElemType; //定义一个队列元素类型,这种编程思路很好,程序有扩展空间//声明一个有关循环队列的...

    #include"stdio.h"

    #include"stdlib.h"

    //这是一个静态队列的例程

    #define MAXSIZE 10   //队列的最大容量

    typedef char ElemType;  //定义一个队列元素类型,这种编程思路很好,程序有扩展空间

    //声明一个有关循环队列的数据块,注意每个元素的意义!

    struct Queue

    {

    ElemType *base;//数据类型头指针

    int front;  //队头(front)进行队列元素删除操作的数组指针索引,很巧妙!

    int rear;  //队尾(rear)进行队列元素插入操作的数组指针索引,很巧妙!

    };

    //创建队列或曰初始化队列

    void Queue_Iinit(Queue * q)

    {

    //   q= new Queue;

    q->base=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));//

    if(!q->base)

    {

    printf("内存分配失败!\n");

    exit(1);

    }

    q->front=q->rear=0;

    //这一步很重要!将队头和队尾指针索引q->front,q->rea都赋值为0,即同时指向数组第一个元素

    }

    //入队操作,入队从队尾rear处开始

    void InsertQueue(Queue * q,ElemType e)

    {

    if((q->rear+1)%MAXSIZE==q->front)//先判断队列是否已满,因为入队从队尾rear处开始,所以先判断rear指针索引

    /*

    表达式(q->rear+1)%MAXSIZE也叫取模运算,该表达式能确保(q->rear+1)%MAXSIZE的结果小于MAXSIZE!

    这样可以确保数组指针不越界。为什么要rear加1呢?腾出一个数据的空闲空间。

    这种算法很技巧!

    */

    {

    printf("队列已满!\n");

    return;

    }

    q->base[q->rear]=e;//

    q->rear=((q->rear+1)%MAXSIZE);//这一步既实现了指针前移同时还实现了指针不越界!技巧!

    }

    //出队操作,出队是从队头front处开始

    void DeleteQueue(Queue * q,ElemType *e)

    {

    if(q->front==q->rear)//已空,说明队列元素已经删除完毕

    {

    printf("老大,队列已空!\n");

    return;

    }

    //   *(e++)=q->base[q->front];//完成此步还不够!还需要指针索引移位!注意赋值方法!

    *e=q->base[q->front];//完成此步还不够!还需要指针索引移位!注意赋值方法!

    q->front=(q->front+1)%MAXSIZE; //指针指向下一个空闲空间,确保不越界

    }

    //判断队列是否为空

    bool EmptyQueue(Queue * q)

    {

    if(q->front==q->rear)    //判断是否为空

    {

    printf("队列已空!\n");

    return true;

    }

    else

    return false;

    }

    //判断队列是否为满

    bool FullQueue(Queue * q)

    {

    if((q->rear+1)%MAXSIZE==q->front)   //判断循环链表是否满,留一个预留空间不用

    {

    printf("队列已满!\n");

    return true;

    }

    else

    return false;

    }

    /***********************************************

    输出每一个元素

    ************************************************/

    void TraverseQueue(Queue * q)

    {

    int i=q->front;

    printf("队中的元素是:\n");

    while( (i%MAXSIZE)!=q->rear )  //注意,这里没有加1,打印每一个元素

    {

    printf("%c\n ",q->base[i]);

    i++;

    }

    printf("\n");

    }

    void main()

    {

    Queue q;

    char c;

    Queue_Iinit(&q);

    printf("请输入循环队列元素,以#作为结束符\n");

    scanf("%c",&c);//注意!本句表示一次输入一个字符

    InsertQueue(&q,c);

    /*

    注意:比如输入“1110010#”再按下回车键,字符串“1110010#”就以一次一个字符的顺序输入到PC键盘缓冲区即入栈;

    出栈时是以“后进先出”的顺序出栈,刚好最后入栈的字符就是二进制的最低位。对于栈的操作一定要注意入栈出栈顺序

    */

    while(c!='#')

    {

    scanf("%c",&c);//这里为什么还要此句呢?因为scanf()一次只能输入一个字符,所以必须循环输入

    InsertQueue(&q,c);

    }

    getchar();//改变键盘输入缓存指针,即将回车键读出来,这样可以避免“\r”字符(回车键)输出

    TraverseQueue(&q);

    printf("开始出队命令!\n");

    while(1)

    {

    DeleteQueue(&q,&c);

    printf("出队:%c\n ",c);

    if( EmptyQueue( &q))

    break;

    }

    }

    展开全文
  • 为了防止“假溢出”,顺序存储我们循环队列来实现,为了便于辨别队列是否已满,通常要保证循环队列满的时候,数组仍有一个空闲空间。 判断循环队列队列已满:( rear + 1 ) % MAXIZE = front 队列为空:rear = ...

    队列:特殊的线性表,“先进先出”,在尾结点处插入,头节点处删除。它也有有顺序存储和链式存储两种存储结构。

    为了防止“假溢出”,顺序存储我们用循环队列来实现,为了便于辨别队列是否已满,通常要保证循环队列满的时候,数组仍有一个空闲空间。

    判断循环队列:
    队列已满:( rear + 1 ) % MAXIZE = front
    队列为空:rear = front
    队列长度:( MAXIZE - front + rear ) % MAXIZE

    队列的结构定义:

    typedef int Status ;
    typedef struct
    {
        int *base ;
        int front ;
        int rear ;
    } SqQueue ;
    
    

    队列初始化:

    void InitQueue( SqQueue *Q )
    {
        Q->base = ( int* )malloc( sizeof( int ) * MAXIZE ) ;
        Q->front = Q->rear = 0 ;
    }
    

    队尾插入:

    Status EnQueue( SqQueue *Q , int val )
    {
        if( ( Q->rear + 1 ) % MAXIZE == Q->front ) //用来保证队列满的时候,数组仍留出一个空闲空间
            return ERROR ;
        else
        {
            Q->base[ Q->rear ] = val ;
            Q->rear = ( Q->rear +1 ) % MAXIZE ;
        }
        return OK ;
    }
    

    队头删除:

    Status DeQueue( SqQueue *Q , int *val )
    {
        if( Q->front == Q->rear )
            return ERROR ;
        else
        {
            *val = Q->base[ Q->front ] ;
            Q->front = ( Q->front + 1 ) % MAXIZE ;
            return OK ;
        }
    }
    

    遍历队列:

    void TraverseQueue( SqQueue Q )
    {
        int i = Q.front ;
        while( i != Q.rear )
        {
            printf( "%d " , Q.base[ i ] ) ;//也可以是其他操作
            i = ( i + 1 ) % MAXIZE ;
        }
        printf( "\n" ) ;
    }
    

    取队头元素:

    Status GetHead( SqQueue Q , int *e )
    {
        if( Q.front == Q.rear )
            return ERROR ;
        else
        {
            *e = Q.base[ Q.front ] ;
            return OK ;
        }
    }
    

    求队列的长度:

    Status GetLength( SqQueue Q )
    {
        return ( MAXIZE - Q.front + Q.rear ) % MAXIZE ;
    }
    

    销毁队列:

    void DesQueue( SqQueue *Q )
    {
        free( Q->base ) ;
        Q->base = NULL ;
        Q->front = Q->rear = 0 ;
    }
    

    源代码:

    #include<stdio.h>
    #include<stdlib.h>
    
    #define MAXIZE 5
    #define ERROR 0
    #define OK 1
    
    typedef int Status ;
    typedef struct
    {
        int *base ;
        int front ;
        int rear ;
    } SqQueue ;
    
    void InitQueue( SqQueue *Q ) ;
    Status EnQueue( SqQueue *Q , int val ) ;
    Status DeQueue( SqQueue *Q , int *val ) ;
    Status GetHead( SqQueue Q , int *e ) ;
    Status GetLength( SqQueue Q ) ;
    void TraverseQueue( SqQueue Q ) ;
    void DesQueue( SqQueue *Q ) ;
    
    int main( void )
    {
        int val , e ;
        SqQueue Q ;
        InitQueue( &Q ) ;
        EnQueue( &Q , 3 ) ;
        EnQueue( &Q , 4 ) ;
        EnQueue( &Q , 5 ) ;
        EnQueue( &Q , 6 ) ;
    
            TraverseQueue( Q ) ;
        DeQueue( &Q , &val ) ;
            TraverseQueue( Q ) ;
        printf( "被删除的元素是:%d\n" , val ) ;
    
        EnQueue( &Q , 777 ) ;
            TraverseQueue( Q ) ;
        GetHead( Q , &e ) ;
        printf( "现在队列的头元素是:%d\n" , e ) ;
        printf( "现在队列的长度是:%d\n" , GetLength( Q ) ) ;
    
        DesQueue( &Q ) ;
        return 0 ;
    }
    
    void InitQueue( SqQueue *Q )
    {
        Q->base = ( int* )malloc( sizeof( int ) * MAXIZE ) ;
        Q->front = Q->rear = 0 ;
    }
    
    Status EnQueue( SqQueue *Q , int val )
    {
        if( ( Q->rear + 1 ) % MAXIZE == Q->front ) //用来保证队列满的时候,数组仍留出一个空闲空间
            return ERROR ;
        else
        {
            Q->base[ Q->rear ] = val ;
            Q->rear = ( Q->rear +1 ) % MAXIZE ;
        }
        return OK ;
    }
    
    Status DeQueue( SqQueue *Q , int *val )
    {
        if( Q->front == Q->rear )
            return ERROR ;
        else
        {
            *val = Q->base[ Q->front ] ;
            Q->front = ( Q->front + 1 ) % MAXIZE ;
            return OK ;
        }
    }
    
    void TraverseQueue( SqQueue Q )
    {
        int i = Q.front ;
        while( i != Q.rear )
        {
            printf( "%d " , Q.base[ i ] ) ;
            i = ( i + 1 ) % MAXIZE ;
        }
        printf( "\n" ) ;
    }
    
    Status GetHead( SqQueue Q , int *e )
    {
        if( Q.front == Q.rear )
            return ERROR ;
        else
        {
            *e = Q.base[ Q.front ] ;
            return OK ;
        }
    }
    
    Status GetLength( SqQueue Q )
    {
        return ( MAXIZE - Q.front + Q.rear ) % MAXIZE ;
    }
    
    void DesQueue( SqQueue *Q )
    {
        free( Q->base ) ;
        Q->base = NULL ;
        Q->front = Q->rear = 0 ;
    }
    
    
    展开全文
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼#defineMAX10/*规定队列中可存放的字节数,[1~254]*/typedefenum{FALSE,TRUE}boolean;booleanSaveNumber(unsignedchar*q,unsignedchar*front,unsignedchar*rear,unsigned...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    #define MAX 10 /*规定队列中可存放的字节数,[1~254]*/

    typedef enum{FALSE,TRUE} boolean;

    boolean SaveNumber(

    unsigned char *q,

    unsigned char *front,

    unsigned char *rear,

    unsigned char *ch);

    boolean DelNumber(

    unsigned char *q,

    unsigned char *front,

    unsigned char *rear,

    unsigned char *ch);

    int main(){

    unsigned char Queue[MAX+1],front=0,rear=1,c;

    char ch;

    boolean (*pntr[2])(

    unsigned char *,unsigned char *,

    unsigned char *,unsigned char *)={SaveNumber,DelNumber};

    const char *Message[]={

    /*0*/"Number %d saved successfully.",

    /*1*/"\nGet %u from the Queue.\n",

    /*2*/"Failed.",

    /*3*/"[1]Save a number into Queue.",

    /*4*/"[2]Get and Delete a number from Queue.",

    /*5*/"[3]Exit.",

    };

    do{

    clrscr();

    printf("%s\n",Message[3]);

    printf("%s\n",Message[4]);

    printf("%s\n",Message[5]);

    printf("Select:");

    switch(ch=getche()){

    int i;

    case '1':

    printf("\nInput a number between 0 and 255:");

    scanf("%d",&i);

    c=i;

    case '2':

    ch-=49;

    break;

    case '3':

    return(0);

    default:continue;

    }

    if(pntr[ch](Queue,&front,&rear,&c))printf(Message[ch],c);

    else printf(Message[2]);

    printf("\nPress any key...");

    getch();

    }while(1);

    }

    boolean SaveNumber(q,front,rear,ch)

    unsigned char *q,*front,*rear,*ch;

    {

    if(*front==*rear){

    printf("Sorry, the Queue is full.\n");

    return(FALSE);

    }else{

    q[*rear]=*ch;

    *rear=(*rear+1)%(MAX+1);

    return(TRUE);

    }

    }

    boolean DelNumber(q,front,rear,ch)

    unsigned char *q,*front,*rear,*ch;

    {

    if((*front+1)%(MAX+1)==*rear){

    printf("\nSorry, the Queue is empty.\n");

    return(FALSE);

    }else{

    *front=(*front+1)%(MAX+1);

    *ch=q[*front];

    return(TRUE);

    }

    }

    展开全文
  • C语言动态创建队列

    2013-12-26 20:12:59
    这是一个动态创建数据结构队列的例子,工作中可以参考甚至使用,不过还是侧重学习比较好,欢迎下载。
  • C语言创建队列

    2019-09-28 11:38:12
    创建队列,入队,出队,输出,统计长度函数 #define ERROR 1 #include<stdio.h> #include<stdlib.h> typedef int Data; typedef struct QNode { Data data; struct QNode* next; }QNode,*QueuePtr; ...

    一个简单的链队列

    有创建队列,入队,出队,输出,统计长度函数

    #define ERROR 1
    #include<stdio.h>
    #include<stdlib.h>
    typedef int Data;
    typedef struct QNode {
    	Data data;
    	struct QNode* next;
    }QNode,*QueuePtr;
    typedef struct LinkQueue {
    	QueuePtr front, rear;
    }LinkQueue;
    int InitQueue(LinkQueue& Q)
    {
    	QueuePtr head = (QueuePtr)malloc(sizeof(QNode));
    	head->next = NULL;
    	head->data = NULL;
    	Q.front = Q.rear = head;
    	return 0;
    }
    int EnQueue(LinkQueue& Q)
    {
    	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    	p->next = NULL;
    	printf("请输入结点数据: ");
    	scanf_s("%d", &p->data);
    	Q.rear->next = p;
    	Q.rear = p;
    	return 0;
    }
    int OutQueue(LinkQueue& Q, Data &e)
    {
    	QueuePtr d;
    	if (Q.front == Q.rear) {
    		return ERROR;
    	}
    	d = Q.front->next;
    	e = d->data;
    	Q.front->next = d->next;
    	if (Q.rear == d) {
    		Q.rear = Q.front;
    	}
    	free(d);
    	return 0;
    }
    void GetHead(LinkQueue& Q, Data e)
    {
    	e = Q.front->next->data;
    }
    void OutputQueue(LinkQueue& Q)
    {
    	QueuePtr p;
    	p = Q.front->next;
    	while (p != NULL) {
    		printf("%d ", p->data);
    		p = p->next;
    	}
    }
    int check_length(LinkQueue& Q)
    {
    	int length = 0;
    	QueuePtr p;
    	p = Q.front;
    	while (p->next != NULL) {
    		p = p->next;
    		length++;
    	}
    	return length;
    }
    

    下面是用switch做目录的交互界面

    int main()
    {
    	int i, e, sl, num;
    	LinkQueue Q;
    	do {
    		printf("请选择功能:\n");
    		printf("创建一个队列...1\n入队操作...2\n出队并显示队列状态...3\n退出...0\n");
    		scanf_s("%d", &sl);
    		switch (sl) {
    		case 0:exit(0); break;
    		case 1:InitQueue(Q); system("pause"); system("cls");  break;
    		case 2:printf("请问需要入队几次?  "); scanf_s("%d", &num); 
    			   for (i = 0; i < num; i++) { EnQueue(Q); }
    			   system("pause"); system("cls"); break;
    		case 3:if (OutQueue(Q, e)) { printf("队列已被清空"); }
    			   else { printf("删除队首 %d;", e); printf("队中还剩余%d个数据:", check_length(Q)); OutputQueue(Q); }
    			   system("pause"); system("cls"); break;
    		}
    	} while (1);
    	return 0;
    }
    

    把上面的函数及头文件和下面的main函数复制粘贴就可以直接运行了

    展开全文
  • 创建队列 c语言_在C中创建队列

    千次阅读 2020-07-18 22:14:52
    创建队列 c语言A queue in C is basically a linear data structure to store and manipulate the data elements. It follows the order of First In First Out (FIFO). C语言中的队列基本上是用于存储和操作数据...
  • 使用c语言定义队列

    2019-09-12 01:48:42
    上一篇实现了栈,底层使用的是数组,但是实现队列的话,数组就不太方便了,因为入队和出队不是在同一个位置进行的。可以想象一下数组实现队列的话,我们需要定义一个多长的数组呢?所以显然对于一般的队列而言,...
  • 简单C语言队列函数

    2013-01-04 14:14:54
    C语言队列的函数实现现,帮助对于C语言实现队列数据结构
  • C语言队列创建

    千次阅读 2020-03-19 18:21:53
    数据结构之队列队列是另一...那么我们就来谈一下它的具体实现,这里主要使用链式存储方式。 下面是代码 #include<stdio.h> #include<stdlib.h> 创建一个链表结构 typedef struct QueueNode { int da...
  • //指向队列最后一个元素的下一个元素 } QUEUE, *PQUEUE; QUEUE CreateQueue(); void TraverseQueue(PQUEUE Q); int FullQueue(PQUEUE Q); int EmptyQueue(PQUEUE Q); int Enqueue(PQUEUE Q, Data val); int ...
  • 使用C语言实现队列

    2018-06-29 16:09:58
     * 创建双向链表  * @return 成功,返回0;否则,返回-1。  */ int create_queue() { phead = create_node(NULL); if (!phead) { return -1; } count = 0; return 0; } /**  * 判断双向链表是否为...
  • /*构造一个空队列*/ Queue *InitQueue() { Queue *pqueue = (Queue *)malloc(sizeof(Queue)); if(pqueue!=NULL) { pqueue->front = NULL; pqueue->rear = NULL; pqueue->size = 0; //pqueue->status=1; ...
  • c语言实现的链式队列、顺序队列还有循环队列的建立。代码完整可以直接运行的。
  • C语言实现队列

    2019-08-16 17:20:19
     //创建新节点  Queue newNode = (Queue)malloc(sizeof(LNode));  if(!newNode){  printf("内存已满!入队失败!\n");  return 0;  }  newNode->data = e;  q->next = newNode;  return 1; } //...
  • 本片博客主要内容:创建新结点初始化队列入队列队列返回对头元素返回队尾元素计算队列长度判断队列是否为空,为空返回1,否则返回零###1、初始化队列void QueueInit (Queue* q)//初始化队列{QNode *cur = (QNode *...
  • 操作系统:进程的五状态模拟模型用C语言队列实现 //解决scanf返回值被忽略报错的问题,任选一个即可 //#define _CRT_SECURE_NO_WARNINGS #pragma warning(disable:4996) #include <stdio.h> #include<...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,272
精华内容 18,108
关键字:

如何用c语言创建队列

c语言 订阅