链式队列实现

三个文件:main.c student.c student.h

student.h文件如下:

#ifndef STUDENT_H_
#define STUDENT_H_

#include<stdio.h>
#include<string.h>
#include<malloc.h>
#include<stdlib.h>

#define CMD_ADD_NODE  ‘1‘
#define CMD_DEL_NODE  ‘2‘
#define CMD_SHOW_NODE ‘3‘
#define CMD_QUIT_NODE  ‘4‘ 

#define MAX 10

typedef struct
{
    char name[20];
    int grade;
}Item;
typedef struct node
{
    Item item;
    struct node *next;
}Node;
typedef struct
{
    Node *front; /* 队头指针 */
    Node *rear;  /* 队尾指针 */
    int items;
}Queue;

static inline void print(const Item item)
{
    printf("%s, %d\n", item.name, item.grade);
    return ;
}

int QueueAdd( Queue *queue,Item item);
int QueueDel(Queue *queue, Item *item);
int QueueShow(const Queue *queue);

#endif

main.c文件如下:

#include"student.h"

int main(int argc, char **argv)
{
    char cmd = 0;
    Queue queue={NULL,NULL,0};
    Item item;

    //Initialize(&queue);
    while(1)
    {
        printf("The Menun Is:\n");
        printf("1.add\n");
        printf("2.delete\n");
        printf("3.show\n");
        printf("4.quit\n");
        printf("Enter your choice(1~4):");

        cmd = getchar();
        while( (getchar()) != ‘\n‘ )
            continue;//跳过输入行的多余部分
        while( cmd != CMD_ADD_NODE && cmd != CMD_DEL_NODE
                           && cmd != CMD_SHOW_NODE && cmd != CMD_QUIT_NODE)
        {
            printf("Please input 1~4:");
            cmd = getchar();
            while( (getchar()) != ‘\n‘ )
                    continue;//跳过输入行的多余部分
        }

        switch(cmd)
        {
            case CMD_ADD_NODE  :
                printf("Enter name and grade:");
                scanf("%s%d",item.name,&(item.grade));
                while( (getchar()) != ‘\n‘ )
                    continue;//跳过输入行的多余部分
                QueueAdd(&queue, item);
                break;

            case CMD_DEL_NODE  :
                QueueDel(&queue, &item);
                printf("Delete:");
                print(item);
                break;

            case CMD_SHOW_NODE  :
                QueueShow(&queue);
                break;

            case CMD_QUIT_NODE  :
                exit(0);
                break;

            default:
                break;
        }
        printf("\n");
    }
    return 0;
}

student.c文件如下:

#include "student.h"

static int  QueueIsEmpty(const  Queue *queue)
{
        return (queue->items == 0);
}

static int QueueIsFull(const Queue *queue)
{
        return (queue->items == MAX);
}

/* 插到队尾 */
int QueueAdd(Queue *queue, Item item)
{
    Node *node;

    if( QueueIsFull(queue) )
    {
            fprintf(stderr,"The queue is full!!!\n");
            return -1;
    }

    node = (Node *)malloc(sizeof(Node));
    if(node == NULL)
    {
        fprintf(stderr, "Cannot creat a node!!!\n");
        return -1;
    }
    node->item = item;
    node->next = NULL;

    if( QueueIsEmpty(queue) )
    {
            queue->front = node;
    }
    else
    {
            queue->rear->next = node;
    }
    queue->rear = node;
    queue->items ++;

    return 0;
}

/* 在队头删除 */
int QueueDel( Queue *queue,  Item *item )
{
        Node *node;

        if( QueueIsEmpty(queue) )
        {
                fprintf(stderr, "The queue is empty!!!\n");
                return -1;
        }

        *item = queue->front->item;
        node = queue->front;
        queue->front = node->next;
        queue->items --;

        free(node);

        return 0;
}

int  QueueShow( const Queue *queue )
{
        int i;
        Node *node = queue->front;

        if( QueueIsEmpty(queue) )
        {
                fprintf(stderr, "The queue is empty!!!\n");
                return -1;
        }

        printf("All of the student:\n");
        for( i=0; i<(queue->items); i++ )
        {
                print(node->item);
                node = node->next;
        }
        printf("\n");

        return 0;
}
时间: 2024-10-12 17:50:36

链式队列实现的相关文章

数据结构Java实现07----队列:顺序队列&amp;顺序循环队列、链式队列、顺序优先队列

数据结构Java实现07----队列:顺序队列&顺序循环队列.链式队列.顺序优先队列 一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其另一端进行删除操作. 队列中允许进行插入操作的一端称为队尾,允许进行删除操作的一端称为队头.队列的插入操作通常称作入队列,队列的删除操作通常称作出队列. 下图是一个依次向队列中插入数据元素a0,a1,...,an-

数据结构之---C语言实现链式队列

//链式队列的存储 //杨鑫 #include <stdio.h> #include <stdlib.h> typedef int QElemType; //定义节点 typedef struct QNode { QElemType data; struct QNode *next; }QNode, *QueuePtr; //定义指针 typedef struct { QueuePtr front; QueuePtr rear; }LinkQueue; //插入元素e进入队列 vo

【数据结构-队列】链式队列

关于链式队列 链式队列又称为链队,是使用单链表实现的,需要一个头指针一个尾指针 结构图: 链队需要的元素组成 /*链式队列的每一个节点*/ struct node{ int data;//存储数据 struct node *next;//指向下一个节点的指针 }; /*链式队列*/ typedef struct{ struct node *head;//头指针 struct node *tail;//尾指针 }LinkedQueue; 创建一个带头节点的空队列 创建一个节点p 将p节点的next

有序链式队列

  编写头文件 struct queue { int num;            //代表数据 int high;           //优先级1111 struct queue *pNext;//存储下一个节点的地址 }; typedef  struct queue Queue;                           //简化队列 Queue * init(Queue *queueHead);                        //初始化 Queue *

C++链式队列

LinkQueue: //链式队列 #include<iostream> using namespace std; typedef int elemType; struct QNode { elemType data; QNode *next; }; struct LinkQueue { QNode *front; QNode *rear; }; //初始化 void InitQueue(LinkQueue *q) { q->front = q->rear = new QNode;

数据结构基础(14) --链式队列的设计与实现

链式队列是基于单链表的一种存储表示, 其形状如下图所示: (队列的队头指针指向单链表的第一个结点, 队尾指针指向单链表的最后一个结点, 注意没有无用的空[头/尾]节点) 用单链表表示的链式队列特别适合于数据元素变动比较大的情况, 而且不存在队列满而产生溢出的情况; 链式队列结点构造: [这次我们将节点构造成了类LinkQueue的嵌套类] struct ChainNode { ChainNode(const Type &_data, ChainNode *_next = NULL) :data(

链式队列的实现

链式队列数据结构如下: typedef struct qnode{ ElemType data; struct qnode* next; //指向下一节点指针 }QNode; typedef struct{ QNode* front; //队首指针 QNode* rear; //队尾指针 }ListQueue; 实现以下函数: void InitQueue(ListQueue* &q); //初始化队列 void ClearQueue(ListQueue* &q); //清空队列 int

不带头结点的链式队列进出队操作

/* 不带头结点的链式队列进出队操作 */ #include <stdio.h> #include <stdlib.h> #define ElementType int typedef struct QNode *Queue; typedef struct Node{ ElementType Data; struct Node *Next; }; typedef struct QNode{ struct Node *front; struct Node *rear; }; void

顺序队列和链式队列的实现

队列是一种常用的数据结构,它跟栈一样,操作都受到限制,队列只允许从一端进数据,另一端出数据.队列跟栈不同,栈是一种"后进先出"的模式,而队列是一种"先进先出"的操作模式.就好比日常排队一样,先排队的先出,后排队的后出.例如,进入队列的顺序是1,2,3,4,5则出队列的顺序是1,2,3,4,5(只考虑一次性出列的情况). 队列也分顺序队列和链式队列,跟顺序栈和链表栈一样,顺序队列同样是基于数组实现,链式队列则是基于链表实现. 顺序队列: //顺序队列 #include

链式队列总结

基本数据结构之-链式队列 链式队列就是一个操作受到限制的单链表,学会了单链表再来写这个就是轻松加愉快,但是貌似我去用了两个小时搞定,主要是基础差! 队列的基本操作就是入栈和出栈,还可以看到对头和对尾 如果维护了长度参数,那么也可以返回一个长度 不说理论了,直接上代码吧! 首先定义基本数据结构的结构体: typedef struct _LINKQUEUENODE { struct _LINKQUEUENODE *next; }LinkQueueNode; typedef struct _LINKQ