数据结构 2 第二章 线性结构 代码实现

news2024/11/23 13:56:56

头文件

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>//malloc函数头文件
#include <time.h>
#include <string.h>
#include <limits.h>
#include <ctype.h>
#include <math.h>
# include <stdio.h>

一、单链表

1.单链表

线性表：1.有限的序列 2.序列中的每一个元素都有唯一的前驱和后继，除了开头和结尾的两个节点。

顺序表：分配一块连续的内存去存放这些元素，eg、数组

链表：内存是不连续的，元素会各自被分配一块内存，内存和内存之间用指针进行相连。

顺序表和链表的区别是内存的连续与否

 data域 | next指针域 ——> data域 | next指针域 ——> data域 | next指针域 ——> NULL

2.单链表的操作

1.增加 ：1>头插法 2>尾插法
1>插入——> data域 | next指针域 ——> data域 | next指针域 ——> data域 | next指针域 ——> NULL
2>data域 | next指针域 ——> data域 | next指针域 ——> data域 | next指针域 ——> 插入——>NULL
2.删除：用前一个节点的指针直接指向对应节点的后一个节点的前驱，只操作一个指针。
为了使操作方便，在操作中添加一个头节点。头节点并不实际存储，只保存链表中的元素个数。

代码实现

1.定义一个结构体

typedef struct Node {//定义一个结构体
	int data;
	struct Node* next;
}Node;

2.初始化一个链表 

Node* initList() {//初始化一个链表
	Node* list = (Node*)malloc(sizeof(Node));
	list->data = 0;
	list->next = NULL;
	return list;
}

 3.头插法

void headInsert(Node* list,int data){//头插法
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = list->next;
	list->next = node;
	list->data++;//代表当前链表之中插入元素
}

4.尾插法

void tailInsert(Node* list, int data){//尾插法
	Node* head = list;
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	list = list->next;
	while (list->next) {
		list = list->next;
	}
	list->next = node;
	head->data++;
}

5.删除操作

void Delete(Node* list, int data){//删除
	Node* head = list;
	Node* pre = list;
	Node* current = list->next;
	list = list->next;
	while (current)
	{
		if (current->data == data)
		{
			pre->next = current->next;
			free(current);
			break;
		}
		pre = current;
		current = current->next;
	}
	list->data--;
}

 6.遍历打印操作

void printList(Node* list) {//遍历操作
	list = list->next;
	while (list)
	{
		printf("%d ", list->data);
		list = list->next;
	}
	printf("\n");
}

 7.代码实现

typedef struct Node {//定义一个结构体
	int data;
	struct Node* next;
}Node;

Node* initList() {//初始化一个链表
	Node* list = (Node*)malloc(sizeof(Node));
	list->data = 0;
	list->next = NULL;
	return list;
}

void headInsert(Node* list,int data){//头插法
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = list->next;
	list->next = node;
	list->data++;//代表当前链表之中插入元素
}

void tailInsert(Node* list, int data){//尾插法
	Node* head = list;
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	list = list->next;
	while (list->next) {
		list = list->next;
	}
	list->next = node;
	head->data++;
}

void Delete(Node* list, int data){//删除
	Node* head = list;
	Node* pre = list;
	Node* current = list->next;
	list = list->next;
	while (current)
	{
		if (current->data == data)
		{
			pre->next = current->next;
			free(current);
			break;
		}
		pre = current;
		current = current->next;
	}
	list->data--;
}

void printList(Node* list) {//遍历操作
	list = list->next;
	while (list)
	{
		printf("%d ", list->data);
		list = list->next;
	}
	printf("\n");
}

int main()
{
	Node* list = initList();
	headInsert(list, 1);
	headInsert(list, 2);
	headInsert(list, 3);
	headInsert(list, 4);
	headInsert(list, 5);
	tailInsert(list, 6);
	tailInsert(list, 7);
	tailInsert(list, 8);
	tailInsert(list, 9);
	tailInsert(list, 10);
	printList(list);
	Delete(list, 5);
	printList(list);
	Delete(list, 10);
	printList(list);
	Delete(list, 6);
	printList(list);
	return 0;
}

8.结果

二、单循环链表

1..单循环链表

data|next——>data|next——>data|next——>头节点
1.初始化链表
2.增加节点（头插法、尾插法）
3.删除节点
4.遍历链表

代码实现

1.定义一个结构体

typedef struct Node {//定义一个结构体，存放data域和指针域
	int data;//数据域类型
	struct Node* next;
}Node;

2. 初始化链表

Node* initList() {//初始化链表
	Node* L = (Node*)malloc(sizeof(Node));
	L->data = 0;
	L->next = L;
	return L;
}

3.头插法

void headInsert(Node* L, int data) {//头插法
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = L->next;
	L->next = node;
}

4尾插法

void tailInsert(Node* L, int data) {//尾插法
	Node* n = L;
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	while (n->next != L) {
		n = n->next;
	}
	node->next = L;
	n->next = node;
}

5.删除操作

int Delete(Node* L, int data)//删除
{
	Node* preNode = L;
	Node* node = L->next;
	while (node != L)
	{
		if (node->data == data) {
			preNode->next = node->next;
			free(node);
			return TRUE;
		}
		preNode = node;
		node = node->next;
	}
	return FALSE;
}

6.遍历链表打印

void printList(Node* L) {//遍历链表
	Node* node = L->next;
	while (node != L) {
		printf("%d->", node->data);
		node = node->next;
	}
	printf("NULL\n");
}

7.代码实现

#define TRUE 1
#define FALSE 0

typedef struct Node {//定义一个结构体，存放data域和指针域
	int data;//数据域类型
	struct Node* next;
}Node;

Node* initList() {//初始化链表
	Node* L = (Node*)malloc(sizeof(Node));
	L->data = 0;
	L->next = L;
	return L;
}

void headInsert(Node* L, int data) {//头插法
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = L->next;
	L->next = node;
}

void tailInsert(Node* L, int data) {//尾插法
	Node* n = L;
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	while (n->next != L) {
		n = n->next;
	}
	node->next = L;
	n->next = node;
}

int Delete(Node* L, int data)//删除
{
	Node* preNode = L;
	Node* node = L->next;
	while (node != L)
	{
		if (node->data == data) {
			preNode->next = node->next;
			free(node);
			return TRUE;
		}
		preNode = node;
		node = node->next;
	}
	return FALSE;
}

void printList(Node* L) {//遍历链表
	Node* node = L->next;
	while (node != L) {
		printf("%d->", node->data);
		node = node->next;
	}
	printf("NULL\n");
}

int main()
{
	Node* L = initList();
	headInsert(L, 1);
	headInsert(L, 2);
	headInsert(L, 3);
	headInsert(L, 4);
	headInsert(L, 5);
	tailInsert(L, 6);
	tailInsert(L, 7);
	tailInsert(L, 8);
	tailInsert(L, 9);
	tailInsert(L, 10);
	printList(L);
	Delete(L, 4);
	Delete(L, 5);
	printList(L);
	return 0;
}

8.结果

三、双链表

1.双链表

pre指针|data域|next指针<——>pre|data|next<——>pre|data|next
 与单链表相比多一个指针域

2.双链表的操作：

 1.初始化链表
 2.插入节点（头插法、尾插法）
 3.删除结点
 4.遍历链表

代码实现

1.数据结构的定义

typedef struct Node {//数据结构的定义
	int data;//data域
	struct Node* pre;//pre指针
	struct Node* next;//next指针
}Node;

2. 初始化链表

Node* initList() {//初始化链表
	Node* L = (Node*)malloc(sizeof(Node));//新建指针变量并开辟空间 返回一个Node*类型指针
	L->data = 0;//头节点data域初始化为0
	L->pre = NULL;//头指针为NULL
	L->next = NULL;//next指针为NULL
	return

3. 头插法

void headInsert(Node* L, int data) {//头插法
	Node* node = (Node*)malloc(sizeof(Node));//新建一个结点并为他开辟空间
	node->data = data;
	if (L->data == 0)
	{
		node->next = L->next;
		node->pre = L;
		L->next = node;
	}
	else {
		node->pre = L;//node指向的pre指向头节点
		node->next = L->next;
		L->next->pre = node;
		L->next = node;
		L->data++;
	}
}

4.尾插法

void tailInsert(Node* L,int data) //尾插法
{
	Node* node = L;
	Node* n = (Node*)malloc(sizeof(Node));
	n->data = data;
	while (node->next) {
		node = node->next;
	}
	n->next = node->next;
	node->next = n;
	n->pre = node;
	L->data++;
}

 5.删除操作

int Delete(Node* L, int data) //删除
{
	Node* node = L->next;
	while (node) 
	{
		if (node->data == data)
		{
			node->pre->next = node->next;
			node->next->pre = node->pre;
			free(node);
			return TRUE;
		}
		node = node->next;
	}
	return FALSE;
}

6.遍历链表打印

void printList(Node* L)//遍历
{
	Node* node = L->next;
	while (node) {
		printf("%d -> ", node->data);
		node = node->next;
	}
	printf("NULL\n");
}

 7.代码实现

#define TRUE 1
#define FALSE 0

typedef struct Node {//数据结构的定义
	int data;//data域
	struct Node* pre;//pre指针
	struct Node* next;//next指针
}Node;

Node* initList() {//初始化链表
	Node* L = (Node*)malloc(sizeof(Node));//新建指针变量并开辟空间 返回一个Node*类型指针
	L->data = 0;//头节点data域初始化为0
	L->pre = NULL;//头指针为NULL
	L->next = NULL;//next指针为NULL
	return L;//返回L
}

void headInsert(Node* L, int data) {//头插法
	Node* node = (Node*)malloc(sizeof(Node));//新建一个结点并为他开辟空间
	node->data = data;
	if (L->data == 0)
	{
		node->next = L->next;
		node->pre = L;
		L->next = node;
	}
	else {
		node->pre = L;//node指向的pre指向头节点
		node->next = L->next;
		L->next->pre = node;
		L->next = node;
		L->data++;
	}
}

void tailInsert(Node* L,int data) //尾插法
{
	Node* node = L;
	Node* n = (Node*)malloc(sizeof(Node));
	n->data = data;
	while (node->next) {
		node = node->next;
	}
	n->next = node->next;
	node->next = n;
	n->pre = node;
	L->data++;
}

int Delete(Node* L, int data) //删除
{
	Node* node = L->next;
	while (node) 
	{
		if (node->data == data)
		{
			node->pre->next = node->next;
			node->next->pre = node->pre;
			free(node);
			return TRUE;
		}
		node = node->next;
	}
	return FALSE;
}

void printList(Node* L)//遍历
{
	Node* node = L->next;
	while (node) {
		printf("%d -> ", node->data);
		node = node->next;
	}
	printf("NULL\n");
}

int main()
{
	Node* L = initList();
	headInsert(L, 1);
	headInsert(L, 2);
	headInsert(L, 3);
	headInsert(L, 4);
	printList(L);
	//4 -> 3 -> 2 -> 1 -> NULL
	tailInsert(L, 5);
	tailInsert(L, 6);
	tailInsert(L, 7);
	tailInsert(L, 8);
	printList(L);
	//4 -> 3 -> 2 -> 1 -> 5 -> 6 -> 7 -> 8 -> NULL
	Delete(L, 2);
	Delete(L, 4);
	printList(L);
	//1 -> 5 -> 6 -> 7 -> 8->NULL
}

8.结果

 

四、双循环链表

1.双循环链表

pre前指针|data域|next后指针<——>pre|data|next<——>pre|data|next
最后一个节点的next指针和头节点的pre指针相互指向对方，其他节点与双链表相同。
功能：
 1.初始化链表
 2.插入节点（头插法、尾插法）
 3.删除结点
 4.遍历链表

代码实现

1.定义一个结构体链表数据节点

typedef struct Node//定义一个结构体类型
{
	int data;
	struct Node* pre;
	struct Node* next;
}Node;

2.初始化链表 

Node* initList()//初始化链表
{
	Node* L = (Node*)malloc(sizeof(Node));
	L->data = 0;
	L->next = L;
	L->pre = L;
	return L;
}

3.头插法

void headInsert(Node* L,int data)//头插法
{
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	if (L->data == 0)
	{//链表为空
		node->pre = L;
		node->next = L->next;
		L->next = node;
		L->pre = node;
		L->data++;
	}
	else {
		//链表不为空
		node->next = L->next;
		node->pre = L;
		L->next->pre = node;
		L->next = node;
		L->data++;
	}
}

4.尾插法 

void tailInsert(Node* L,int data)//尾插法
{
	Node* node = L;
	while (node->next != L)
	{
		node = node->next;
	}
	Node* n = (Node*)malloc(sizeof(Node));
	n->data = data;
	n->pre = node;
	n->next = L;
	L->pre = n;
	node->next = n;
	L->data++;
}

5.删除操作

int Delete(Node* L, int data)//删除
{
	Node* node = L->next;
	while (node != L)
	{
		if (node->data == data)
		{
			node->pre->next = node->next;
			node->next->pre = node->pre;
			free(node);
			L->data--;
			return 1;
		}
		node = node->next;
	}
	return 0;
}

 6.遍历链表打印

void printList(Node* L)//遍历
{
	Node* node = L->next;
	while (node != L) {
		printf("%d -> ", node->data);
		node = node->next;
	}
	printf("NULL\n");
}

7.代码实现

typedef struct Node//定义一个结构体类型
{
	int data;
	struct Node* pre;
	struct Node* next;
}Node;

Node* initList()//初始化链表
{
	Node* L = (Node*)malloc(sizeof(Node));
	L->data = 0;
	L->next = L;
	L->pre = L;
	return L;
}

void headInsert(Node* L,int data)//头插法
{
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	if (L->data == 0)
	{//链表为空
		node->pre = L;
		node->next = L->next;
		L->next = node;
		L->pre = node;
		L->data++;
	}
	else {
		//链表不为空
		node->next = L->next;
		node->pre = L;
		L->next->pre = node;
		L->next = node;
		L->data++;
	}
}

void tailInsert(Node* L,int data)//尾插法
{
	Node* node = L;
	while (node->next != L)
	{
		node = node->next;
	}
	Node* n = (Node*)malloc(sizeof(Node));
	n->data = data;
	n->pre = node;
	n->next = L;
	L->pre = n;
	node->next = n;
	L->data++;
}

int Delete(Node* L, int data)//删除
{
	Node* node = L->next;
	while (node != L)
	{
		if (node->data == data)
		{
			node->pre->next = node->next;
			node->next->pre = node->pre;
			free(node);
			L->data--;
			return 1;
		}
		node = node->next;
	}
	return 0;
}

void printList(Node* L)//遍历
{
	Node* node = L->next;
	while (node != L) {
		printf("%d -> ", node->data);
		node = node->next;
	}
	printf("NULL\n");
}

int main()
{
	Node* L = initList();
	headInsert(L, 1);
	headInsert(L, 2);
	headInsert(L, 3);
	headInsert(L, 4);
	printList(L);
	//4 -> 3 -> 2 -> 1 -> NULL
	tailInsert(L, 5);
	tailInsert(L, 6);
	tailInsert(L, 7);
	tailInsert(L, 8);
	printList(L);
	//4 -> 3 -> 2 -> 1 -> 5 -> 6 -> 7 -> 8 -> NULL
	Delete(L, 2);
	Delete(L, 4);
	printList(L);
	//3 -> 1 -> 5 -> 6 -> 7 -> 8 -> NULL
}

 8.运行结果

五、栈

1.栈

存放：1->2->3 取出:3->2->1   先进后出
应用场景：1.表达式的值 2.解决一些递归问题 3.计算进制转换
栈是一种特殊的线性表，它只能在一端进行存取操作，所以存取的元素有先进后出的特点。
栈的总体特点：先进后出

2.实现的功能：

 初始化栈
 出栈
 入栈
 判断栈空

代码实现

1.结构体定义数据结点

typedef struct Node //结构体创建节点
{
	int data;//data域
	struct Node* next;//next指针
}Node;

2.初始化栈

Node* initStack()//初始化栈
{
	Node* S = (Node*)malloc(sizeof(Node));//新建一个节点
	S->data = 0;
	S->next = NULL;
	return S;//返回S
}

3.出栈 

int isEmpty(Node* S)//出栈功能前的判断栈空功能
{
	if (S->data == 0 || S->next == NULL)//栈空
	{
		return 1;
	}
	else {
		return 0;
	}
}

int getTop(Node* S)//出栈 传入头指针
{
	if (isEmpty(S))
	{
		return -1;
	}
	else
	{
		return S->next->data;//不为空的话 S指向第一个节点的data域
	}
}

4. 

 

六、队

1.队

一种先进先出的特殊线性表，只允许在一端进行存取，在头出，在尾进

2.实现的功能：

1.初始化队
2.出队
3.入队 （尾插法）

代码实现

1.结构体定义数据节点

typedef struct Node //定义数据节点结构体
{
	int data;//数据域data
	struct Node* next;//next指针
}Node;

2.初始化队列

Node* initQueue() //初始化队列
{
	Node* Q = (Node*)malloc(sizeof(Node));//新建指针变量
	Q->data = 0;
	Q->next = NULL;
	return Q;
}

3. 入队操作 尾插法

void enQueue(Node* Q, int data)//入队操作 尾插法
{
	Node* q = Q;//传入头指针
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	for (int i = 0; i < Q->data; i++)//循环遍历队列找到最后一个节点
	{
		q = q->next;
	}
	node->next = q->next;
	q->next = node;
	Q->data++;//!!!!
}

 4.出队操作，删除队列中第一个结点

int isEmpty(Node* Q)//判空
{
	if (Q->data == 0 || Q->next == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

int deQueue(Node* Q) //出队操作 删除队列中的第一个节点
{
	if (isEmpty(Q))//判空操作
	{
		return -1;
	}
	else
	{
		Node* node = Q->next;
		int data = node->data;
		Q->next = node->next;
		free(node);
		return data;
	}
}

5.遍历队列打印

void printQueue(Node* Q)//遍历队列打印
{
	Node* node = Q->next;//传入第一个节点
	while (node)
	{
		printf("%d -> ", node->data);
		node = node->next;
	}
	printf("NULL\n");
}

6.代码实现

typedef struct Node //定义数据节点结构体
{
	int data;//数据域data
	struct Node* next;//next指针
}Node;

Node* initQueue() //初始化队列
{
	Node* Q = (Node*)malloc(sizeof(Node));//新建指针变量
	Q->data = 0;
	Q->next = NULL;
	return Q;
}

void enQueue(Node* Q, int data)//入队操作 尾插法
{
	Node* q = Q;//传入头指针
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	for (int i = 0; i < Q->data; i++)//循环遍历队列找到最后一个节点
	{
		q = q->next;
	}
	node->next = q->next;
	q->next = node;
	Q->data++;//!!!!
}

int isEmpty(Node* Q)//判空
{
	if (Q->data == 0 || Q->next == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

int deQueue(Node* Q) //出队操作 删除队列中的第一个节点
{
	if (isEmpty(Q))//判空操作
	{
		return -1;
	}
	else
	{
		Node* node = Q->next;
		int data = node->data;
		Q->next = node->next;
		free(node);
		return data;
	}
}

void printQueue(Node* Q)//遍历队列打印
{
	Node* node = Q->next;//传入第一个节点
	while (node)
	{
		printf("%d -> ", node->data);
		node = node->next;
	}
	printf("NULL\n");
}

int main()
{
	Node* Q = initQueue();
	enQueue(Q, 1);
	enQueue(Q, 2);
	enQueue(Q, 3);
	enQueue(Q, 4);
	printQueue(Q);//1 -> 2 -> 3 -> 4 -> NULL
	int data = deQueue(Q);
	printf("data=%d\n", data);//data=1
	printQueue(Q);//2 -> 3 -> 4 -> NULL
	data = deQueue(Q);
	printQueue(Q);//3 -> 4 -> NULL

	data = deQueue(Q);
	printQueue(Q);//4 -> NULL

	data = deQueue(Q);
	printf("data=%d\n", data);//data=4
	printQueue(Q);//NULL
	return 0;
}

7.运行结果

 

七、循环队列

队列组成一周 需要两个指针指向队列的队首与队尾 当插入一个元素后，队尾指针后移一项，

如何判断队列是空/满：
 1.在实际操作中，牺牲掉队列一个空间来判断队列是满/空
 2.判断逻辑如下：
   1>队空的话，头指针等于尾指针：front==rear
     2>队满的话：rear+1%MAXSIZE==front;

实现的功能：

  1.初始化队列
  2.入队
  3.出队
  4.遍历循环队列

 代码实现

1.定义队列结构体

#define MAXSIZE 5

typedef struct Queue//定义队列结构体
{
	int front;//front指针
	int rear;//rear指针
	int data[MAXSIZE];//data域
}Queue;

2.初始化队列 

Queue* initQueue()//初始化队列
{
	Queue* Q = (Queue*)malloc(sizeof(Queue));
	Q->front = Q->rear = 0;
	return Q;
}

3.判满/空操作

int isFull(Queue* Q)//判满操作
{
	if ((Q->rear + 1) % MAXSIZE == Q->front)
	{
		return 1;
	}
	else {
		return 0;
	}
}

int isEmpty(Queue* Q)//判空操作
{
	if (Q->front == Q->rear)
	{
		return 1;
	}
	else {
		return 0;
	}
}

 4.入队操作

int enQueue(Queue* Q, int data)//插入函数 入队操作
{
	if (isFull(Q))
	{
		return 0;
	}
	else {
		Q->data[Q->rear] = data;
		Q->rear = (Q->rear + 1) % MAXSIZE;
		return 1;
	}
}

 5。出队操作

int deQueue(Queue* Q)//出队操作
{
	if (isEmpty(Q))
	{
		return -1;
	}
	else {
		int data = Q->data[Q->front];
		Q->front = (Q->front + 1) % MAXSIZE;
		return data;
	}
}

6，遍历队列打印

void printQueue(Queue* Q)//遍历队列打印
{
	//要知道队列当前有多少个元素
	int length = (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
	int index = Q->front;
	for (int i = 0; i < length; i++)
	{
		printf("%d -> ", Q->data[index]);
		index = (index + 1) % MAXSIZE;
	}
	printf("NULL\n");
}

7.代码实现

#define MAXSIZE 5

typedef struct Queue//定义队列结构体
{
	int front;//front指针
	int rear;//rear指针
	int data[MAXSIZE];//data域
}Queue;

Queue* initQueue()//初始化队列
{
	Queue* Q = (Queue*)malloc(sizeof(Queue));
	Q->front = Q->rear = 0;
	return Q;
}

int isFull(Queue* Q)//判满操作
{
	if ((Q->rear + 1) % MAXSIZE == Q->front)
	{
		return 1;
	}
	else {
		return 0;
	}
}

int isEmpty(Queue* Q)//判空操作
{
	if (Q->front == Q->rear)
	{
		return 1;
	}
	else {
		return 0;
	}
}

int enQueue(Queue* Q, int data)//插入函数 入队操作
{
	if (isFull(Q))
	{
		return 0;
	}
	else {
		Q->data[Q->rear] = data;
		Q->rear = (Q->rear + 1) % MAXSIZE;
		return 1;
	}
}

int deQueue(Queue* Q)//出队操作
{
	if (isEmpty(Q))
	{
		return -1;
	}
	else {
		int data = Q->data[Q->front];
		Q->front = (Q->front + 1) % MAXSIZE;
		return data;
	}
}

void printQueue(Queue* Q)//遍历队列打印
{
	//要知道队列当前有多少个元素
	int length = (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
	int index = Q->front;
	for (int i = 0; i < length; i++)
	{
		printf("%d -> ", Q->data[index]);
		index = (index + 1) % MAXSIZE;
	}
	printf("NULL\n");
}

int main()
{
	Queue* Q = initQueue();
	enQueue(Q, 1);
	enQueue(Q, 2);
	enQueue(Q, 3);
	enQueue(Q, 4);
	printQueue(Q);//1 -> 2 -> 3 -> 4 -> NULL
	deQueue(Q);
	printQueue(Q);//2 -> 3 -> 4 -> NULL
	return 0;
}

8.运行结果

 

 

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1100571.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Segment Anything（论文解析）

Segment Anything（论文解析）

Segment Anything 摘要1.介绍2 SAM任务SAM模型 摘要 我们介绍了“Segment Anything” (SA) 项目&#xff1a;这是一个新的任务、模型和数据集对于图像分割。使用我们高效的模型进行数据收集&#xff0c;我们构建了迄今为止最大的分割数据集&#xff08;远远超过其他数据集&…
阅读更多...
C语言进行实验：通过程序实现线算图取值【支持VC++ 6.0编辑器环境运行】

C语言进行实验：通过程序实现线算图取值【支持VC++ 6.0编辑器环境运行】

背景&#xff1a; 一、实验目的和要求 1、能描述数据基本类型及其常量的表示方法&#xff1b; 2、会对变量进行定义及初始化&#xff1b; 3、能使用运算符与表达式对变量赋值&#xff1b; 4、会描述C语句的概念及种类、C语言常用的输入/出方式&#xff1b; 5、会设计顺序…
阅读更多...
typora主题切换与推荐主题

typora主题切换与推荐主题

在这篇博文中&#xff0c;我将向你展示如何给typora更换主题&#xff0c;并推荐几款出色的主题。通过这些主题的使用&#xff0c;你可以为你的typora编辑器增添一抹别样的风采&#xff0c;让你的写作体验更加美好、舒适。 typora替换主题的步骤非常简单&#xff0c;只需按照以…
阅读更多...
科技资讯|苹果Vision Pro可通过手势ID检测不同用户

科技资讯|苹果Vision Pro可通过手势ID检测不同用户

近日&#xff0c;美国专利局公布了苹果公司的一项专利申请&#xff0c;该专利申请涉及基于手部特征验证用户身份的技术。苹果指出&#xff0c;可能是多个家庭成员都想使用 Apple Vision Pro&#xff0c;系统必须识别不同的手势以控制 visionOS。在另一个示例中&#xff0c;苹果…
阅读更多...
无频闪护眼灯哪个好？五款无频闪护眼台灯推荐

无频闪护眼灯哪个好？五款无频闪护眼台灯推荐

青少年的近视率持续升高&#xff0c;保护眼睛非常重要。台灯是用眼环境的必备品&#xff0c;而市面上款式多样不知如何购买。这期就来聊聊护眼台灯的选购问题&#xff01; 都说成人的世界不容易&#xff0c;社交网络上时常有人吐槽996工作制&#xff0c;但要知道的是现在的学生…
阅读更多...
(vue)el-descriptions 描述列表无效

(vue)el-descriptions 描述列表无效

(vue)el-descriptions 描述列表无效 原因&#xff1a;element 的版本不够 解决&#xff1a;运行下面两个命令 npm uninstall element-ui //卸载之前安装的版本 npm i element-ui -S //重新安装解决参考&#xff1a;https://blog.csdn.net/weixin_59769148/article/details/1…
阅读更多...
vector+算法sort与list+sort的效率比较，容易写错的地方原因探析

vector+算法sort与list+sort的效率比较，容易写错的地方原因探析

我写的代码&#xff1a; #include <iostream> using namespace std; #include <vector> #include <list> #include <algorithm> int main() {const int N 10000000;vector<int> v;list<int> l;for (int i 0; i < N; i){v.push_back(…
阅读更多...
SpringCloud Gateway网关梳理

SpringCloud Gateway网关梳理

前言 在中大型系统中&#xff0c;Gateway网关发挥着关键的作用&#xff0c;Gateway可以运用在许多应用场景&#xff0c;如接口限流、日志监控、授权认证等等。下面对过往的Gateway知识做一个归纳与总结。 一、路由 路由是Gateway网关中的基础组件&#xff0c;它由一个org.sp…
阅读更多...
C#开发的OpenRA游戏之金钱系统（2）

C#开发的OpenRA游戏之金钱系统（2）

C#开发的OpenRA游戏之金钱系统（2） 在我们玩这个游戏时，就会发现每当创建一个新精炼工厂，就会带有一台采矿车，这是怎么样实现的呢？ 这个就需要查看建筑物下面这个字段： FreeActor: Actor: HARV SpawnOffset: 1,2 Facing: 256 FreeActor就是标记为免费的物品，在这里
阅读更多...
xdma axi-stream

xdma axi-stream

xdma 回环 vivado 里有官方示例 fpga&#xff1a;pcie rx – axi-stream master – axi-stream slave – pcie tx 流程&#xff1a;电脑启动读取&#xff0c;然后电脑再在超时时间内写入。或者电脑启动写入&#xff0c;然后电脑再在超时时间内读出。只读取或只写入会报超时&am…
阅读更多...
小程序开发平台源码系统+活动在线报名小程序功能 带完整的搭建教程

小程序开发平台源码系统+活动在线报名小程序功能 带完整的搭建教程

今天来给大家分享一下小程序开发平台源码系统的活动在线报名小程序功能。活动在线报名小程序是一种方便快捷的活动报名方式&#xff0c;可以通过小程序进行宣传和报名&#xff0c;让参与者可以方便快捷地进行报名和参加活动。小程序有完整的搭建教程&#xff0c;以下是部分功能…
阅读更多...
【14】基础知识：React - redux

【14】基础知识：React - redux

一、 redux理解 1、学习文档 英文文档&#xff1a;https://redux.js.org/ 中文文档&#xff1a;http://www.redux.org.cn/ Github: https://github.com/reactjs/redux 2、redux是什么 redux 是一个专门用于做状态管理的 JS 库(不是 react 插件库)。 它可以用在 react&am…
阅读更多...
记一次MySQL5初始化被kill的问题排查 | 京东云技术团队

记一次MySQL5初始化被kill的问题排查 | 京东云技术团队

写在前面 由于测试环境JED申请比较繁琐&#xff0c;所以Eone提供了单机版Mysql供用户使用&#xff0c;近期Eone搭建Mysql5的时候发现莫名被kill了&#xff0c;容器规格是4C8G&#xff0c;磁盘30G 这不科学&#xff0c;之前都是可以的&#xff0c;镜像没变&#xff0c;配置没变…
阅读更多...
分享大数据培训班班型

分享大数据培训班班型

泰迪大数据培训班有VIP就业保障班&#xff0c;项目实战班&#xff0c;技能进阶班&#xff0c;技能提升班。不同班型对应不同学习服务。 一、VIP 就业保障班 二、大数据分析/开发项目实战班 三、技能进阶班 四、技能提升班
阅读更多...
RabbitMQ 安装和使用Demo

RabbitMQ 安装和使用Demo

同步是阻塞 MQ&#xff1a;消息队列&#xff0c;基础数据结构中"先进先出"的数据结构。用来解决应用解耦&#xff0c;异步消息&#xff0c;流量消峰等问题。 RabbitMQ、RocketMQ、Kafka RocketMQ 是阿里的 应用层开发使用RabbitMQ 大数据开发Kafka MQ是不是微服务都…
阅读更多...
【MATLAB源码-第49期】基于蚁群算法(ACO)算法的栅格路径规划，输出最佳路径图和算法收敛曲线图。

【MATLAB源码-第49期】基于蚁群算法(ACO)算法的栅格路径规划，输出最佳路径图和算法收敛曲线图。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 蚁群算法是一种模拟自然界蚂蚁觅食行为的启发式优化算法。在蚁群系统中&#xff0c;通过模拟蚂蚁之间通过信息素沟通的方式来寻找最短路径。 在栅格路径规划中&#xff0c;蚁群算法的基本步骤如下&#xff1a; 1. 初始化: …
阅读更多...
【Redis】Redis持久化策略

【Redis】Redis持久化策略

目录 策略RDBbgsave执行流程RDB效果演示RDB优缺点 AOFAOF缓冲区刷新策略AOF的重写机制AOF重写机制的触发机制AOF重写流程 混合持久化同时存在aof和rdb快照&#xff0c;以谁为主&#xff1f;信号 策略 RDB > Redis DataBase 相当于定期的方式实现持久化AOF > Append Only…
阅读更多...
Python网络编程改良版客户端

Python网络编程改良版客户端

在《Python中套接字实现客户端和服务端3-3》中提到&#xff0c;客户端可以通过connect()方法连接服务端&#xff0c;而连接成功的前提是服务端在必须客户端连接之前就要等待连接。 1 当客户端连接时&#xff0c;服务端没有打开 如果客户端连接服务端时&#xff0c;服务端并没…
阅读更多...
通过商品ID查询淘宝商品详情数据，可以拿到商品标题，商品价格，商品库存，商品销量，商品sku数据等，淘宝API接口

通过商品ID查询淘宝商品详情数据，可以拿到商品标题，商品价格，商品库存，商品销量，商品sku数据等，淘宝API接口

通过商品ID查询淘宝商品详情数据可以参考以下步骤&#xff1a; 进入淘宝网站&#xff0c;搜索需要查询的商品ID&#xff0c;例如&#xff1a;652874751412。复制该商品的ID号。点击获取请求key和secret地址&#xff0c;请求参数为num_iid商品ID&is_promotion1。发送请求&a…
阅读更多...
企业立案信息API的优势与应用场景

企业立案信息API的优势与应用场景

引言 随着科技的不断进步&#xff0c;创业者和企业家们在创办新企业时愈发依赖数字化工具。其中&#xff0c;企业立案信息API成为了一项重要的资源&#xff0c;它提供了有关企业立案的关键信息&#xff0c;为企业家们提供了许多优势和丰富的应用场景。本文将探讨企业立案信息A…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023