队列及其c语言实现

Posted 2022-12-12 lym152898

队列的基本概念

队列 (Queue) :也是运算受限的线性表。是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。
队首 (front) :允许进行删除的一端称为队首。
队尾 (rear) :允许进行插入的一端称为队尾。

队列中没有元素时称为空队列。在空队列中依次加入元素 a 1 , a 2 , …, a n 之后, a 1 是队首元素, a n 是队尾元素。显然退出队列的次序也只能是 a 1 , a 2 , …, a n ,即队列的修改是依先进先出的原则进行的,如图 3-5 所示。

基本操作

1. 创建新队列
2. 判空
3. 进队
4. 出队
5. 清空队
6. 获得队头元素
7. 遍历队
8. 销毁队
9. 队长

顺序队列

利用一组连续的存储单元 ( 一维数组 ) 依次存放从队首到队尾的各个元素,称为顺序队列。对于队列,和顺序栈相类似,也有动态和静态之分。这里介绍静态顺序队列.其类型定义如
下:

typedef int datatype;
#define MAX_QUEUE_SIZE 100
typedef struct queue
 
    datatype queue_array[MAX_QUEUE_SIZE];
    int front;
    int rear;
sp_queue;

设立一个队首指针 front ,一个队尾指针rear ,分别指向队首和队尾元素。
◆ 初始化: front=rear =0。
◆ 入队:将新元素插入 rear 所指的位置,然后rear 加 1 。
◆ 出队:删去 front 所指的元素,然后加 1 并返回被删元素。
◆ 队列为空: front=rear 。
◆ 队满: rear = MAX_QUEUE_SIZE - 1 或front=rear 。

在非空队列里,队首指针始终指向队头元素,而队尾指针始终指向队尾元素的下一位置。顺序队列中存在“假溢出”现象。因为在入队和出队操作中,头、尾指针只增加不减小,致使被删除元素的空间永远无法重新利用。因此,尽管队列中实际元素个数可能远远小于数组大小,但可能由于尾指针巳超出向量空间的上界而不能做入队操作。该现象称为假溢出。如图 3-6 所示是数组大小为 5 的顺序队列中队首、队尾指针和队列中元素的变化情况。

代码实现

/* 顺序队列接口定义头文件*/
#define true 1
#define false 0


/* 队的最大长度 */
#define MAX_QUEUE_SIZE 100
/* 队列的数据类型 */
typedef int datatype;

/* 静态链的数据结构 */
typedef struct queue
    datatype sp_queue_array[MAX_QUEUE_SIZE];
    /* 队头 */
    int front;
    /* 队尾 */
    int rear;
sp_queue;


/* 静态顺序链的接口定义 */


/* 静态链的初始化 */
sp_queue queue_init();

/* 判断队列是否为空,若为空
 * 返回true
 * 否则返回false
*/
int queue_empty(sp_queue q);


/* 插入元素e为队q的队尾新元素 
 * 插入成功返回true
 * 队满返回false
*/
int queue_en(sp_queue *q, datatype e);


/* 队头元素出队
 * 用e返回出队元素,并返回true
 * 若队空返回false
*/
int queue_de(sp_queue *q, datatype *e);

/* 清空队 */
void queue_clear(sp_queue *q);


/* 获得队头元素
 * 队列非空,用e返回队头元素,并返回true
 * 否则返回false
*/
int get_front(sp_queue, datatype *e );


/* 获得队长 */
int queue_len(sp_queue q);

/* 遍历队 */
void queue_traverse(sp_queue q, void(*visit)(sp_queue q));


void visit(sp_queue s);


/* 接口实现文件 */
#include<stdio.h>
#include<stdlib.h>
#include"sp_queue.h"


sp_queue queue_init()

    sp_queue q;
    q.front = q.rear = 0;
    return q;




int queue_empty(sp_queue q)

    return q.front == q.rear;



int queue_en(sp_queue *q, datatype e)

    /* 队满 */
    if (q -> rear == MAX_QUEUE_SIZE)
        return false;

    /* 入队 */
    q -> sp_queue_array[q -> rear] = e;
    printf("q.sp_queue_array[%d]=%d\\n", q -> rear, e);
    q -> rear += 1;
    return true;




int queue_de(sp_queue *q, datatype *e)

    /* 队空 */
    if(queue_empty(*q))
        return false;

    /* 出队 */
    q -> rear -= 1;
    *e = q -> sp_queue_array[q -> rear];
    return true;



void queue_clear(sp_queue *q)

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



int get_front(sp_queue q, datatype *e)

    /* 队空 */
    if(q.front == q.rear)
        return false;

    /* 获取队头元素 */
    *e = q.sp_queue_array[q.front];
    return true;



int queue_len(sp_queue q)

    return (q.rear - q.front);



void queue_traverse(sp_queue q, void (*visit)(sp_queue q))

    visit(q);


void visit(sp_queue q)

    /* 队空 */
    if (q.front == q.rear)
        printf("队列为空\\n");

    int temp = q.front;
    while(temp != q.rear)
    
        printf("%d ",q.sp_queue_array[temp]);
        temp += 1;
    
    printf("\\n");




int main()

    sp_queue q = queue_init();
    queue_en(&q, 1);
    queue_en(&q, 2);
    printf("length=%d\\n", queue_len(q));
    queue_en(&q, 3);
    printf("length=%d\\n", queue_len(q));
    queue_en(&q, 4);
    printf("length=%d\\n", queue_len(q));
    queue_en(&q, 5);
    printf("length=%d\\n", queue_len(q));
    queue_en(&q, 6);
    printf("length=%d\\n", queue_len(q));
    queue_traverse(q,visit);
    datatype *e = (datatype *)malloc(sizeof(*e));
    queue_de(&q,e);
    printf("queue_de(),e=%d length=%d\\n", *e, queue_len(q));
    queue_traverse(q, visit);
    queue_clear(&q);
    queue_traverse(q, visit);
    printf("length:%d\\n", queue_len(q));

注意:结构体变量作为函数的参数和其他普通变量一样,值只会在函数体内被修改,想要通过函数更改结构体的值,可以通过结构体指针作为函数的参数实现.

队列的链式表示和实现

队列的链式存储结构简称为链队列,它是限制仅在表头进行删除操作和表尾进行插入操作的单链表。需要两类不同的结点:数据元素结点,队列的队
首指针和队尾指针的结点,如图 3-8 所示。

数据元素结点类型定义:

typedef struct q_node
    datatype data;
    struct q_node *next;
q_node;

指针结点类型:

typedef struct 
    q_node *front;
    q_node *rear;   
link_queue;

链队运算及指针变化

链队的操作实际上是单链表的操作,只不过是删除
在表头进行,插入在表尾进行。插入、删除时分别修改
不同的指针。链队运算及指针变化如图 3-9 所示。

代码实现

/* 链式栈接口的定义头文件 */
#define true 1
#define false 0


/* 队列的数据类型 */
typedef int datatype;

/* 静态链的数据结构 */
typedef struct q_node
    datatype data;
    struct q_node *next;
q_node,*link_node;

typedef struct l_queue
    /* 队头指针 */
    q_node *front;
    /* 队尾指针 */
    q_node *rear;
*link_queue;


/* 静态顺序链的接口定义 */


/* 静态链的初始化 */
link_queue queue_init();

/* 判断队列是否为空,若为空
 * 返回true
 * 否则返回false
*/
int queue_empty(link_queue q);

/* 插入元素e为队q的队尾新元素 
 * 插入成功返回true
 * 队满返回false
*/
int queue_en(link_queue q, datatype e);


/* 队头元素出队
 * 用e返回出队元素,并返回true
 * 若队空返回false
*/
int queue_de(link_queue q, datatype *e);

/* 清空队 */
void queue_clear(link_queue q);

/* 销毁队 */
void queue_destroy(link_queue q);

/* 获得队头元素
 * 队列非空,用e返回队头元素,并返回true
 * 否则返回false
*/
int get_front(link_queue q, datatype *e );


/* 获得队长 */
int queue_len(link_queue q);

/* 遍历队 */
void queue_traverse(link_queue q, void(*visit)(link_queue q));


void visit(link_queue q);



/* 接口的实现文件 */
#include<stdio.h>
#include<stdlib.h>
#include"lp_queue.h"



link_queue queue_init()

    /* 新建头结点 */
    link_node new_node = (link_node)malloc(sizeof(q_node));
    new_node -> next = NULL;
    /* 指针结点 */
    link_queue q = (link_queue)malloc(sizeof(*q));
    q -> front = q -> rear = new_node;
    return q;



int queue_empty(link_queue q)

    return q -> front == q -> rear;



int queue_en(link_queue q, datatype e)

    /* 新建数据结点 */
    link_node new_node = (link_node)malloc(sizeof(q_node));
    /* 内存分配失败 */
    if(!new_node)
        return false;
    new_node -> data = e;
    q -> rear -> next = new_node;
    q -> rear = new_node;
    return true;


int queue_de(link_queue q, datatype *e)

    /* 队列为空 */
    if (q -> front == q -> rear)
        return false;

    *e = q -> front -> next -> data;
    link_node temp = q -> front -> next;
    q -> front -> next = temp -> next;
    /* 防止丢失尾指针 */
    if (temp == q.rear -> next)
        q -> rear = q -> front; 
    free(temp);
    temp = NULL;
    return true;


void queue_clear(link_queue q)

    /* 头结点 */
    link_node head = q -> front -> next;
    head -> next = NULL;
    q -> front = q -> rear = head;
    /* 第一个结点 */
    link_node temp = head -> next;
    while(temp)
    
        link_node p = temp;
        temp = p -> next;
        free(p);
        p = NULL;
    



void queue_destroy(link_queue q)

    queue_clear(q);
    free(q);
    q = NULL;



int get_front(link_queue q, datatype *e)

    /* 队为空 */
    if (q -> front == q -> rear)
        return false;

    *e = q -> front -> next -> data;
    link_node temp = q -> front -> next;
    q -> front -> next = temp -> next;
    free(temp);
    temp = NULL;
    return true;



int queue_len(link_queue q)

    /* 头结点 */
    link_node p = q -> front -> next;
    /* 计数器 */
    int count = 0;
    while(p)
    
        count += 1;
        p = p -> next;
    
    return count;



void queue_traverse(link_queue q, void(*visit)(link_queue q))

    visit(q);


void visit(link_queue q)

    /* 头结点 */
    link_node p = q -> front -> next;
    if(!p)
    
        printf("队列为空");
    
    while(p)
    
        printf("%d ", p -> data);
        p = p -> next;
    
    printf("\\n");


int main()

    link_queue q = queue_init();
    queue_en(q, 1);
    queue_en(q, 2);
    printf("length=%d\\n", queue_len(q));
    queue_en(q, 3);
    printf("length=%d\\n", queue_len(q));
    queue_en(q, 4);
    printf("length=%d\\n", queue_len(q));
    queue_en(q, 5);
    printf("length=%d\\n", queue_len(q));
    queue_en(q, 6);
    printf("length=%d\\n", queue_len(q));
    queue_traverse(q,visit);
    datatype *e = (datatype *)malloc(sizeof(*e));
    queue_de(q,e);
    printf("queue_de(),e=%d length=%d\\n", *e, queue_len(q));
    queue_traverse(q, visit);
    queue_clear(q);
    queue_traverse(q, visit);
    printf("length:%d\\n", queue_len(q));

执行结果: