队列的基本认识和操作

最新推荐文章于 2023-05-11 20:43:26 发布
最新推荐文章于 2023-05-11 20:43:26 发布
阅读量976 收藏 8
点赞数 3
分类专栏： C语言学习 文章标签： 队列 指针 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55124878/article/details/116062934
版权

队列的基本认识和操作

一.队列的基础知识

1.定义：

队列是一种可以实现 “先进先出” 的存储结构。 也可以理解为一种特殊的链表，它只允许在链表的一端进行插入，在链表的另一端删除元素，不可以在中间操作。如同我们平常去排队买票，先到的先买到票就可以先走，后来的就只能等轮到自己时才可以买票走。

2.队列的分类

队列的分类
链式队列和静态队列的大体相同，不过实现方法不同。

队列的结构图：
链表队列

静态队列

对于队列也是受限的线性表,但是由于顺序存储会出现假溢出，所以出现了循环队列的结构防止顺序存储的队列出现溢出假现象，链队列不会出现这种情况。

3.队列通常定义的参数：

①.一个队列通常由 队头（front） 和 队尾（rear） 两个参数确定。
②.两个参数不同场合的不同含义：
  • 队列初始化
    front 和 rear 的值都是零。
  • 队列非空
    front 代表的是队列的第一个元素。
    rear 代表的是队列的最后一个有效元素的下一个元素。
  • 队列为空
    front 和 rear 的值相等，但不一定是零。

二.链式队列的建立和基本操作

1.队列所需的结构体

//链式队列结点
typedef struct Node {
	int data;            //数据域
	struct Node *pNode;  //指针域
}NODE, *PNODE;

//链式队列
typedef struct awsl { 
	PNODE front;    //指向队头
	PNODE rear;     //指向队尾
}AWSL, *PAWSL;

2.队列初始化

链式队列就像链表，所以就要初始化的时候动态开辟内存或者用数组的形式为其开辟内存，除了要开辟内存外，还要初始化结构中的其他项，尤其注意指针域，不初始化可能会对计算机已存储的数值产生影响。当 队头（front）和 队尾（rear）相等时表示队列为空，即 队头（front）和 队尾（rear）指向同一个结点。

//队列初始化
void init_awsl(PAWSL ps) {
	PNODE t = (PNODE)malloc(sizeof(NODE));  //请求计算机分配一个动态的内存，作为队头
	if (NULL == t) {
		printf("内存不足！1\n");
		exit(-1);
	}     //辨别计算机是否有足够的内存分配给该程序，作为队列结点存储数据
	ps -> rear = ps -> front = t;  //令队头和队尾都指向新创建的结点，便于后续的入队和出队
	t -> pNode = NULL;    //使结点初始化，避免成为野指针，影响程序数据的存储
	return;
}

3.入队

入队操作只能从队尾， 链式队列不用担心队列是否已满，但是我们先要保证内存空间要有，所以就要先判断计算机是否有足够的空间分配给该函数，然后就是尾插，先使队尾（rear）指向的结点指向新创建的结点，再使 队尾（rear）为新插入的结点。

//入队
void push_awsl(PAWSL ps) {
	if (NULL != ps -> rear -> pNode) {
	    printf("请初始化！\n");
	    return;
	}   //判断队尾结点是否初始化，防止其成为野指针对程序造成影响
	PNODE t = (PNODE)malloc(sizeof(NODE));  //请求计算机分配一个动态的内存，作为新入列的结点
	if (NULL == t) {
		printf("内存不足！\n");
		exit(-1);
	}  //辨别计算机是否有足够的内存分配给该程序，作为队列结点存储数据
	printf("要入列的元素是：");
	scanf("%d", &ps -> rear -> data);  //输入新插入的结点存储的数据
	ps -> rear -> pNode = t;    //将原队尾结点指向新创建的结点，使新创建的结点作为队尾
	ps -> rear = t;             //将 原队尾(rear)指向新创建的结点
	t -> pNode = NULL;          //使新创建的结点指向为空
	return;
}

4.出队

出队操作只能从队头出队，对于链式队列只需要将 队头（front）指向下一个结点，再释放掉原 队头（front）位置的空间即可。

//出队
void go_awsl(PAWSL ps) {
	PNODE t = ps -> front;   //定义一个该队列结构体类型的指针指向队头（front），便于对队头元素的出列操作
	if ((NULL == t -> pNode) || (NULL != ps -> rear -> pNode)) {
		printf("队列为空！出列失败。\n");
		return;
	}   //判断原队列是否为空
	ps -> front = t -> pNode;   //将原队头（front）指向下一个结点，从而达到使原队头数据出列的效果
	printf("出列的元素是；%d\n", t -> data);
	free(t);     //释放计算机分配给原队头的内存
	return;
}

5.遍历队列

对于队列的遍历，只需要定义一个指针从 队头（front）到 队尾（rear）将每个结点存储的数据逐一输出即可。

//遍历队列
void traverse_awsl(PAWSL ps) {
	PNODE t = ps -> front;    //定义一个该队列结构体类型的指针指向队头，使其在队列中移动遍历队列
	if ((NULL == t -> pNode) || (NULL != ps -> rear -> pNode)) {
		printf("队列为空！遍历失败。\n");
		return;
	}   //判断队列是否为空，为空则不需要遍历
	printf("队列内的元素：\n");
	while (t != ps -> rear) {
		printf("%d\n", t -> data);
		t = t -> pNode;
	}     //让新定义的指针t从 队头（front）到 队尾（rear）遍历队列
	return;
}

6.清空队列

从 队头（front）开始直到 队尾（rear），队头（front）每往后走一个，就释放掉 队头（front）原指向的结点即可。

//清空
void empty_awsl(PAWSL ps) {
	if (NULL != ps -> rear -> pNode) {
	    printf("请初始化！\n");
	    return;
	}   //判断队尾结点是否初始化，防止其成为野指针对程序造成影响
	while (ps -> front != ps -> rear) {
		PNODE t = ps -> front;
		ps -> front = t -> pNode;
		free(t);
	}     //将数据从 队头（front）到队尾（rear）逐一释放
	printf("已清空！\n");
	return;
}

7.链式队列源代码.

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

typedef struct Node{     //节点
	int data;
	struct Node *pNode;
}NODE, *PNODE;

typedef struct awsl {    //链式队列
	PNODE front;
	PNODE rear;
}AWSL, *PAWSL;

void init_awsl(PAWSL);//初始化
void push_awsl(PAWSL);//入列
void go_awsl(PAWSL);//出列
void traverse_awsl(PAWSL);//遍历
void empty_awsl(PAWSL);//清空

//主函数
int main(void) {
	AWSL S;
	init_awsl(&S);
	push_awsl(&S);
	push_awsl(&S);
	push_awsl(&S);
	go_awsl(&S);
	traverse_awsl(&S);
	empty_awsl(&S);
	traverse_awsl(&S);
	return 0;
}
//初始化
void init_awsl(PAWSL ps) {
	PNODE t = (PNODE)malloc(sizeof(NODE));
	if (NULL == t) {
		printf("内存不足！1\n");
		exit(-1);
	}
	ps -> rear = ps -> front = t;
	t -> pNode = NULL;
	return;
}
//入列
void push_awsl(PAWSL ps) {
	if (NULL != ps -> rear -> pNode) {
	    printf("请初始化！\n");
	    return;
	}
	PNODE t = (PNODE)malloc(sizeof(NODE));
	if (NULL == t) {
		printf("内存不足！\n");
		exit(-1);
	}
	printf("要入列的元素是：");
	scanf("%d", &ps -> rear -> data);
	ps -> rear -> pNode = t;
	ps -> rear = t;
	t -> pNode = NULL;
	return;
}
//出列
void go_awsl(PAWSL ps) {
	PNODE t = ps -> front;
	if ((NULL == t -> pNode) || (NULL != ps -> rear -> pNode)) {
		printf("队列为空！出列失败。\n");
		return;
	}
	ps -> front = t -> pNode;
	printf("出列的元素是；%d\n", t -> data);
	free(t);
	return;
}
//遍历
void traverse_awsl(PAWSL ps) {
	PNODE t = ps -> front;
	if ((NULL == t -> pNode) || (NULL != ps -> rear -> pNode)) {
		printf("队列为空！遍历失败。\n");
		return;
	}
	printf("队列内的元素：\n");
	while (t != ps -> rear) {
		printf("%d\n", t -> data);
		t = t -> pNode;
	}
	return;
}
//清空
void empty_awsl(PAWSL ps) {
	if (NULL != ps -> rear -> pNode) {
	    printf("请初始化！\n");
	    return;
	}
	while (ps -> front != ps -> rear) {
		PNODE t = ps -> front;
		ps -> front = t -> pNode;
		free(t);
	}
	printf("已清空！\n");
	return;
}

三.静态队列的建立和基本操作

创建静态队列的前提条件：

所谓的静态队列就是一个循环数组，但是数组是一个线性关系的顺序表，实现数组的循环是静态队列的关键，这就使我们想到了约瑟夫环，利用 % 的原理使数组变成一个环型，即 队头（front）和 队尾（rear）每次移动时并不是向数组一般直接 + 1，而是利用 front = （front + 1）% 数组长度 和 rear = （rear + 1）% 数组长度 来实现环形数组。

使用此方法需要注意的是，顺序队列在判断数组是否已满时，出现下面情况：

  • 当队列为空时，队列的头指针等于队列的尾指针；
  • 当数组满员时，队列的头指针等于队列的尾指针；

顺序队列的存储状态不同，但是判断条件相同。
①为了对其进行区分，最简单的解决办法是： 牺牲掉数组中的一个存储空间.
②判断数组满员的条件是： 尾指针的下一个位置和头指针相遇，就说明数组满了.

1.队列所需的结构体

//定义一个静态队列的结构体
typedef struct queue {
    int *pBase;     //用于指向定义的数组
    int front;      //指向队头
    int rear;       //指向队尾
}QUEUE;

2.队列初始化

静态队列就像数组一样，不过他是一个循环数组，因为需要在被调中定义静态队列，所以需要动态分配内存，除了要开辟内存外，还要初始化结构中的其他项。当 队头（front）和 队尾（rear）相等时表示空，即两数值相同。

//初始化队列
void init(QUEUE *pQ) {
    pQ -> pBase = (int *)malloc(sizeof(int) * 6);  //请求系统分配6个整型单元的空间，这里的6可以随便改为自己需要的数组长度。
    pQ -> front = 0;   //初始化 队头（front），使它表示数组的下标为0
    pQ -> rear = 0;    //初始化 队尾（rear），使它表示数组的下标为0
}

3.判断队列是否存满

当 队尾（rear）的下一个就是 队头（front）时，表示该队列已满。

//判断队列是否存满
bool full_queue(QUEUE *pQ) {
    if ((pQ -> rear + 1) % 6 == pQ -> front) {
        return true;
    } else {
        return false;
    }
}

4.入队

入队操作只能从队尾，入队我们先要保证内存空间要有，所以就要先判断队列是否已满，然后就是尾插，rear表示的是队尾的存储值的空间的下一个，也就是直接把值存进下标为 rear 的空间.。

//入队
bool en_queue(QUEUE *pQ, int val) {
    if (full_queue(pQ)) {  //判断队列是否已满
        return false;
    } else {
        pQ -> pBase[pQ -> rear] = val;   //将值赋给原下标为 rear 的单元
        pQ -> rear = (pQ -> rear + 1) % 6;   //再使 rear 的值为数组下一个单元的下标
        return true;
    }
}

5.判断队列是否为空

当静态队列的 队头（front）和 队尾（rear）值相等时，就表示该队列为空。

//判断队列是否为空
bool empty_queue(QUEUE *pQ){
    if (pQ -> rear == pQ -> front) {
        return true;
    } else {
        return false;
    }
}

6.出队

静态队列的出队，只能从队头出队，对于静态队列，只需要修改 队头（front），使它为下一个单元的下标就可以，这样就可以把数据从逻辑上删除。

//出队
bool out_queue(QUEUE *pQ, int *val) {
    if (empty_queue(pQ)) {    //判断队列是否为空
       return false;
    } else {
        *val = pQ -> pBase[pQ -> front]; //将要出队的值赋给 val 指向的地址
        pQ -> front = (pQ -> front + 1) % 6;   // 再使 front 的值为数组下一个单元的下标
        return true;
    }
}

7.遍历队列

定义一个整型类型的变量，作为下标从 队头（front）遍历到 队尾（rear）并逐一输出。

//遍历队列
void traverse_queue(QUEUE *pQ) {
    int i = pQ -> front;  //i 用于遍历静态队列（循环数组）
    while (i != pQ -> rear) {
        printf("%5d", pQ -> pBase[i]);
        i = (i + 1) % 6;
    }   //从下标为 front 开始到下标为 rear 的单元，逐一输出
    return;
}

8.清空队列

清空静态队列，我们只需要把 队头（front)和 队尾（rear）下标重新指向数组的0下标即可。

//清空队列
bool clear_queue(QUEUE *pQ) {
    pQ -> front = pQ -> rear = 0;
    return true;
}

9.摧毁队列

对于摧毁操作，我们就要把初始化中开辟的内存释放掉并且把 队头（front）和 队尾（rear）赋值为0。

//摧毁队列
bool destory_queue(QUEUE *pQ) {
    free(pQ -> pBase);    //释放动态数组
    pQ -> pBase = NULL;    //使原指向动态数组的指针指向为空，防止其成为野指针影响程序其他值得存储
    pQ -> front = pQ -> rear = 0;  //将 front 和 rear 都归零
    return true;
}

10.静态队列源代码

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>

//定义一个队列的结构体
typedef struct queue {
    int *pBase;
    int front;
    int rear;
}QUEUE;

void init(QUEUE *);  //初始化队列
bool en_queue(QUEUE *, int);  //入队
bool full_queue(QUEUE *);    //判断队列是否满
void traverse_queue(QUEUE *);  //遍历队列
bool out_queue(QUEUE *, int *);    //出队
bool empty_queue(QUEUE *);     //判断队列是否为空
bool clear_queue(QUEUE *pQ); //清空队列
bool destory_queue(QUEUE *pQ); //摧毁队列

int main(void) {
    QUEUE Q;
    int val;
    init(&Q);
    en_queue(&Q, 1);
    en_queue(&Q, 2);
    en_queue(&Q, 3);
    en_queue(&Q, 4);
    en_queue(&Q, 5);
    en_queue(&Q, 6);
    en_queue(&Q, 7);
    traverse_queue(&Q);
    printf("\n");
    if (out_queue(&Q, &val)) {
        printf("出队成功，出队的元素为%2d", val);
    } else {
        printf("出队失败！");
    }
    printf("\n");
    traverse_queue(&Q);
    printf("\n");
    if (clear_queue(&Q)) {
        printf("队列已清空！");
    } else {
        printf("队列清空失败！");
    }
    printf("\n");
    if (destory_queue(&Q)) {
        printf("队列摧毁成功！");
    } else {
        printf("队列摧毁失败！");
    }

    return 0;
}

//初始化队列
void init(QUEUE *pQ) {
    pQ -> pBase = (int *)malloc(sizeof(int) * 6);
    pQ -> front = 0;
    pQ -> rear = 0;
}

//入队
bool en_queue(QUEUE *pQ, int val) {
    if (full_queue(pQ)) {
        return false;
    } else {
        pQ -> pBase[pQ -> rear] = val;
        pQ -> rear = (pQ -> rear + 1) % 6;
        return true;
    }
}

//判断队列是否满
bool full_queue(QUEUE *pQ) {
    if ((pQ -> rear + 1) % 6 == pQ -> front) {
        return true;
    } else {
        return false;
    }
}

//遍历队列
void traverse_queue(QUEUE *pQ) {
    int i = pQ -> front;
    while (i != pQ -> rear) {
        printf("%5d", pQ -> pBase[i]);
        i = (i + 1) % 6;
    }
    return;
}

//出队
bool out_queue(QUEUE *pQ, int *val) {
    if (empty_queue(pQ)) {
       return false;
    } else {
        *val = pQ -> pBase[pQ -> front];
        pQ -> front = (pQ -> front + 1) % 6;
        return true;
    }
}

//判断队列是否为空
bool empty_queue(QUEUE *pQ){
    if (pQ -> rear == pQ -> front) {
        return true;
    } else {
        return false;
    }
}

//摧毁队列
bool destory_queue(QUEUE *pQ) {
    free(pQ -> pBase);
    pQ -> pBase = NULL;
    pQ -> front = pQ -> rear = 0;
    return true;
}

//清空队列
bool clear_queue(QUEUE *pQ) {
    pQ -> front = pQ -> rear = 0;
    return true;
}
西邮郭富城
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
队列的认知和理解
weixin_45762587的博客
03-25 657
队列的认知和理解 队列（Queue） 队列简称队，它也是一种运算受限的线性表。队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。 与堆栈不同，如果说堆栈是几个人进入死胡同，后进的人先出，那么队列更像是几个人排队看电影，先排队的先进场去看。 1.队列的几个概念 把进行插入的一端称做队尾...
数据结构--队列的基础知识
weixin_50311592的博客
04-27 540
队列（Queue） 定义：队列是只允许在一端进行插入==（入队）==，在另一端删除（出队）==的线性表 先进先出（FIFO） 重要术语：队头、队尾、空队尾 队列的基本操作 InitQueue(&Q):初始化队列，构造一个空队列Q DestroyQueue(&Q):销毁队列，销毁并释放队列Q所占的内存空间==（创、销）== EnQueue(&Q,x):入队，若队列Q未满，将x加入。使之成为新的队尾==（增）== DeQueue(&Q,&x):出队，若队列Q非空，删除队
队列概念理解
guangod的博客
08-13 1618
1.队列的概念 只允许在一端插入数据操作，在另一端进行删除数据操作的特殊线性表；进行插入操作的一端称为队尾（入队列），进行删除操作的一端称为队头（出队列）；队列具有先进先出（FIFO）的特性。可以想像一下排队时的情景 队头移动，出队列时队头向后移动一个位置 如果还有新元素进行入队列容易造成假溢出。 假溢出：顺序队列因多次入队列和出队列操作后出现的尚有存储空间但不能进行入队列操作的溢出。 真溢...
队列的入门知识
自由的天空
12-30 783
出处：http://blog.csdn.net/hui12581/article/details/45023197 一、Java  Queue基础 Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 offer，add区别： 一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。 这时新的 offer 方
队列基础篇
weixin_64084604的博客
11-24 471
define MaxSize 10 //定义队列中元素的最大个数//用静态数组存放队列元素//队头指针和队尾指针}SqQueue;（1）声明时：SqQueue Q;（2）front指向队头元素；rear指向队尾元素的后一个位置（下一个应该插入的位置）；（3）这里的front和rear也同样不是数据类型指针，而是功能上类似指针的int型整数，在这里映射的是队头队尾元素的数组下标。typedef struct LinkNode { //链式队列结点int data;
实验二 堆栈和队列基本操作的编程实现
02-09
本次实验重点在于理解和实现堆栈和队列的基本操作，包括创建、进栈、出栈、进队和出队。在顺序栈的实现中，关键在于理解栈顶指针的移动和如何正确处理栈溢出情况。通过实现将十进制数转换为r进制的功能，加深了对栈...
栈和队列的基本操作
01-02
我们可以通过实验，掌握了栈和队列的知识，又学会了一些基本应用实例，例如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。 在附录-实验代码中，我们可以看到实验代码的实现细节，例如队列的初始...
栈与队列的基本操作
11-11
1. 掌握栈的先进后出的特点。 2. 掌握栈的初始化、进栈、退栈、取栈顶、判栈空等基本操作。 3. 运用栈的基本操作解决一些简单的实际问题。...5. 掌握队列的初始化、入队、出队、取队首元素、判队空等基本操作
8584 循环队列的基本操作
06-04
在IT领域，循环队列（Circular Queue）是一种特殊的数据结构，它在数组中实现队列功能，通过将数组尾部与头部相连形成一个圆环，从而优化了队列的存储和操作效率。本文将深入探讨“8584 循环队列的基本操作”，解析...
关于队列，你需要知道这些
question_mark的博客
11-01 314
队列：先进先出 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First InFirst Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头。 队列也是一种特殊的线性表 也是只支持三个核心操作 入队列 出队列 取队首元素 队列的一些进化版本： 1.优先队列。 2.消息队列。给每个数据引入了...
查询一个消息队列的状态，OSQQuery()
FunkyFrog821951259的博客
04-16 1731
OSQQuery()函数使用户可以查询一个消息队列的当前状态。程序清单 L6.27是该函数的源代码。OSQQuery()需要两个参数：一个是指向消息队列的指针pevent。它是在建立一个消息队列时，由OSQCreate()函数返回的；另一个是指向OS_Q_DATA（见uCOS_II.H）数据结构的指针pdata。该结构包含了有关消息队列的信息。在调用OSQQuery()函数之前，必须先定义该数据结
队列
Geek_ymv的专栏
09-08 241
队列 队列是一个有序列表，可以用数组或是链表实现。你可以想象下10年前去火车站排队买票的场景，在同一个窗口排成长长的队，先来的先买，后来的只能站在最后面排队，不允许插队。先来的人先买票（先进先出），后来的后买票（后进后出）。 遵循先入先出的原则，即：先存入队列的数据，要先取出，后存入的要后取出。 示意图： 队列最基本的两个操作：入队（enqueue），放一个数据到队列的尾部；出队（dequeue）从队列头部取一个元素。 顺序队列和链式队列 用数组实现的队列叫顺序队列，用链表实现的队列叫链式队列。 本篇文章
队列详解
Only Sun
07-01 828
队列详解 定义 在这里插入代码片队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 创建队列 创建初始数组 int arr[maxSize] 定义头指针 front = -1，尾指针 rear = -1. 队列的基本操作 添加元素 判断队列是否为满队列，若为满队列则输出提示信息，否则执行2； rear ++ ; arr[rear] = temp
SA_JOB_QUEUE查找队列状态表（查询数据库表的方法）
Grace_1203的博客
10-16 1076
SA_JOB_QUEUE查找队列状态表 今天突然有人问了我一个问题，我们系统的队列状态表在哪一个表中，瞬间懵逼，这对一个时刻操纵着数据库的人来说是多么大的打击。然后我立马找到user_tables的这个表(这个是查询当前用户下的所有的表)。 select * from user_tables ut where ut.TABLE_NAME like '%UEUE%'--SA_JOB_QUEUE...
3.rabbitmq-队列详解
u010895694的博客
01-17 2014
RabbitMQ 中消费行为主要跟队列有直接关系，有这几种类型。 1. 临时队列 2. 自动删除队列 3. 单消费者队列 4. 自动过期队列 5. 永久队列 接下来我们来详细的介绍下这几种类型的队列。 1.临时队列 临时队列对应的是没有持久化的队列,存在于内存中。如果rabbitmq服务器重启,那么这些队列就不会存在。 //将第二个参数,表示是否是持久化的,设置为非持久化的,那么他就是一条默认队列 channel.queueDeclare("temporary-queue", fal
队列文档之顺序队列
二木成林
05-09 2668
队列的顺序实现指分配一块连续的存储单元存放队列中的元素，并附设两个指针：队头指针和队尾指针。
数据结构之队列（链式队列）的基本操作与实现
热门推荐
BaoITcore的博客
11-14 2万+
这篇文章的末尾有完整的实现代码，书写不易，转载请附上本文章链接。 一、链式队列的概念 何为链式队列，想到链式队列大家应该都会想到顺序表的单链表的基本操作，我们来对比一下：单链表是用一个头指针或者是尾指针来实现元素的插入和删除等，即头插法和尾插法。而链式队列呢，我们都知道队列是一个在队首进行出队再队尾进行入队，而不是在一段完成任务，所以我们这里就需要两个指针分别指向队列的头front和尾rear，他们两个各司其职，当要进行出队操作时，头指针front说了算，当要进行入队操作时，尾指针re...
静态链表（初始化，插入，删除）C语言实现
最新发布
weixin_74048545的博客
05-11 706
动态链表就是用数组描述的链表（这种描述方法叫游标实现法），我们让数组的每个元素都由一个结构体组成，结构体有两个成员，data和cursor，而cursor就相当于链表的next指针，用来存放后继元素在数组中的下标。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值