C语言实现数据结构：栈和队列

最新推荐文章于 2024-07-07 16:33:35 发布
最新推荐文章于 2024-07-07 16:33:35 发布
阅读量546 收藏 6
点赞数 1
文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/John_bill/article/details/130002414
版权

第一次上机实验报告

作业题目1：栈的基本操作

程序运行结果截图，需测试各种情况。写出测试过程中遇到的主要问题及所采用的解决措施。

运行结果截图:

 

主要问题：因为没有提前用elemtype定义，所以在代码编写过程中比较拖沓

解决办法：挨个修改代码中的int类型和char类型，以求得统一

代码:

function.h

#pragma once
#include"stack.h"

void menu();
int InitStack(SqStack& S, int n);
int StackTraverse(SqStack S);
int StackLength(SqStack S);
int GetTop(SqStack S);
int Push(SqStack& S, int e);
int Pop(SqStack& S);

stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

typedef struct {
    int* base;
    int* top;
    int stacksize;
}SqStack;

function.cpp

#include"function.h"

void menu()
{
    printf("[1]创建栈\n");
    printf("[2]判断是否为空栈\n");
    printf("[3]入栈\n");
    printf("[4]出栈\n");
    printf("[5]取栈顶元素\n");
    printf("[6]返回栈的长度\n");
    printf("[0]退出\n");
}

int InitStack(SqStack& S, int n) //创建  
{
    S.base = (int*)malloc(STACK_INIT_SIZE * sizeof(int));
    if (!S.base)
    {
        printf("存储分配失败\n");
        return 0;
    }
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    printf("输入栈的元素:\n");
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &*S.top);
        S.top++;
    }
}

int StackTraverse(SqStack S)//遍历
{
    if (S.top == S.base)
    {
        printf("栈为空\n");
        return 0;
    }
    int* p;
    p = S.top;
    while (p > S.base)
    {
        p--;
        printf("%d ", *p);
    }
    printf("\n");
}

int StackLength(SqStack S)//长度
{
    int length = 0;
    if (S.top == S.base)
    {
        printf("栈元素的个数为：%d\n", length);
        return 0;
    }
    int* p;
    p = S.top;
    while (p > S.base)
    {
        p--;
        length++;
    }
    printf("栈元素的个数为：%d\n", length);
}

int GetTop(SqStack S)//显示栈顶
{
    if (S.top == S.base)
    {
        printf("栈为空\n");
        return 0;
    }
    int* p;
    p = S.top;
    p--;
    printf("%d ", *p);
    printf("\n");
}

int Push(SqStack& S, int e)//入栈  
{
    if (S.top - S.base >= S.stacksize)
    {
        S.base = (int*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(int));
        if (!S.base)
        {
            printf("存储分配失败\n");
            return 0;
        }
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++ = e;
}

int Pop(SqStack& S)//出栈  
{
    int e;
    if (S.top == S.base)
    {
        printf("栈为空\n");
        return 0;
    }
    else
    {
        e = *--S.top;
        printf("出栈元素为：%d\n", e);
    }
}

stack.cpp

#include"function.h"

int main()
{
    SqStack S;
    int select, i, e, n;
    while (1)
    {
        printf("\n请输入你的操作：\n");
        menu();
        scanf("%d", &select);
        switch (select)
        {
        case 1:
            printf("输入栈的长度:\n");
            scanf("%d", &n);
            InitStack(S, n);
            StackTraverse(S);
            break;
        case 2:
            if (S.top == S.base)
            {
                printf("栈为空\n");
                break;
            }
            else
            {
                printf("栈非空\n");
                break;
            }
        case 3:
            printf("输入入栈元素\n");
            scanf("%d", &e);
            Push(S, e);
            StackTraverse(S);
            break;
        case 4:
            Pop(S);
            StackTraverse(S);
            break;
        case 5:
            printf("栈顶元素为：");
            GetTop(S);
            StackTraverse(S);
            break;
        case 6:
            StackLength(S);
            break;
        case 0:
            return 0;
        default:
            printf("输入错误\n");
            break;
        }
    }
    return 0;
}

作业题目2：队列的基本操作

程序运行结果截图，需测试各种情况。写出测试过程中遇到的主要问题及所采用的解决措施。

运行结果截图:

 

 

 

 

 主要问题：c++使用不熟练

解决办法：进行百度，学习c++里基本输入输出操作

代码:

line.h

#pragma once
#include<iostream>
#include<cstdlib>
using namespace std;
struct QNode {
	int data;
	QNode* next;
};
typedef QNode* QueuePtr;

struct LinkQueue {
	QueuePtr front;
	QueuePtr rear;
};

源.cpp

#include"line.h"

//初始化队列
bool InitQueue(LinkQueue &Q) {
	Q.front = Q.rear = new QNode;
	if (!Q.front) {
		cout << "初始化失败" << endl;
		return false;
	}
	Q.front->next = NULL;
	cout << "初始化成功" << endl;
	return true;
}

//销毁队列
void DestroyQueue(LinkQueue &Q) {
	while (Q.front) {
		Q.rear = Q.front->next;
		delete (Q.front);
		Q.front = Q.rear;
	}
	cout << "队列已被销毁" << endl;
}

//判断是否为空
bool EmptyQueue(LinkQueue Q) {
	if (Q.front == Q.rear) {
		cout << "队列为空" << endl;
		return true;
	}
	cout << "队列不为空" << endl;
	return false;
}

//入队
void EnQueue(LinkQueue &Q, int value) {
	QueuePtr p = new QNode;
	p->data = value;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	cout << value << " 已经入队" << endl;
}

//出队(一）
void DeQueue(LinkQueue &Q, int &value) {
	if (Q.front == Q.rear) {
		cout << "队列为空" << endl;
		return;
	}
	QueuePtr p = Q.front->next;
	//vlaue保存被删的结点数据
	value = p->data;
	Q.front->next = p->next;
	if (Q.rear == p) {//如果p指向的是尾结点
		Q.rear = Q.front;
	}
	delete p;
	cout << value << " 已经出队" << endl;
}

//出队（二）
void DeQueue2(LinkQueue &Q, int &value) {
	if (Q.front == Q.rear) {
		cout << "队列为空" << endl;
		return;
	}
	QueuePtr p = Q.front;
	Q.front = Q.front->next;
	value = p->data;
	delete p;
	cout << value << " 已经出队" << endl;
}

//队列元素个数
void GetLength(LinkQueue Q, int &length) {
	length = 0;
	QueuePtr p = Q.front;
	while (p != Q.rear) {
		p = p->next;
		length++;
	}
	cout << "队列元素个数" << length << "个" << endl;
}

//显示队列元素
void VisitQueue(LinkQueue Q) {
	if (Q.front == Q.rear) {
		cout << "队列为空" << endl;
		return;
	}
	QueuePtr p = Q.front;
	while (p != Q.rear) {
		p = p->next;
		cout << p->data << " ";
	}
	cout << endl;
}

void show() {
	cout << "+---------------------------+" << endl;
	cout << "|    1->初始化队列          |" << endl;
	cout << "|    2->判断队列是否为空    |" << endl;
	cout << "|    3->入队                |" << endl;
	cout << "|    4->出队                |" << endl;
	cout << "|    5->显示队列元素        |" << endl;
	cout << "|    6->销毁队列            |" << endl;
	cout << "|    7->队列元素个数        |" << endl;
	cout << "+---------------------------+" << endl;
}

int main() {
	LinkQueue Q;
	int action, value, length;
	show();
	while (cin >> action) {
		switch (action) {
		case 1:
			system("cls");
			InitQueue(Q);
			break;
		case 2:
			system("cls");
			EmptyQueue(Q);
			break;
		case 3:
			system("cls");
			cout << "请输入入队的元素" << endl;
			cin >> value;
			EnQueue(Q, value);
			break;
		case 4:
			system("cls");
			DeQueue(Q, value);
			break;
		case 5:
			system("cls");
			VisitQueue(Q);
			break;
		case 6:
			system("cls");
			DestroyQueue(Q);
			break;
		case 7:
			system("cls");
			GetLength(Q, length);
		}
		system("pause");
		show();
	}
}

作业题目3：火车车厢的调度模拟

1.题目描述：

设火车车厢分为3类：硬座、硬卧、软卧，分别用ABC表示。下图描述车厢调度的示意图，图中右端为排列无序的车厢，左端为调度后的车厢排列，使得所有软卧车厢中最前面，所有硬卧车厢中中间，所有硬座车厢中最后。选择合适的存储结构，编程模拟上述车厢调度过程，右端车辆进入用相应的字符串给出，例如“BBACBCAABBCAA”，得到“CCCBBBBBAAAAA”的输出。

2.问题分析：

（1）程序的功能要求；用栈和队列实现字符串的重新排列

（2）程序的界面设计：显示：任意输入一串字符,其中A表示硬座，B表示硬卧，C表示软卧

（3）程序的错误处理：当输入的数不为char类型时，无输出值

1.数据类型设计：

struct Stack {

ElemType* stack;

int top1, top2;//表示栈顶元素的位置

}S;

typedef struct qNode

{

char data;

struct qNode* next;

} QNode, * QueuePtr;

typedef struct {

QNode* front;//队头指针

QNode* rear;//队尾指针   

}LinkQueue;

2.算法设计（算法的基本思想、具体步骤，各程序模块之间的层次（调用）关系流程图等）：用一个队列和两个栈，若是“A”或者“B”，则分别进入两栈，最后遍历到最后一个“C”之后，再进行入队列并且输出的操作。

3.测试分析

设计测试范例（测试数据包括正确的输入、边界条件、含有错误的输入等），列出程序的测试结果（附截图），测试结果的分析与讨论。可列出测试过程中遇到的主要问题及所采用的解决措施。

 

 

4.心得

对实验设计与实现过程的回顾和分析，说明程序的改进思想、经验和体会。

写代码要思路清晰，不然会把自己绕进去。

在前期的设定一定要清晰，不然会给后期带来极大的麻烦。

5.附录

列出程序文件清单，及文件功能。

头文件：

LinkQueue:放函数的操作

源文件：

TRAIN.cpp:放主函数的操作以及结构类型定义，typedef定义和宏定义等

代码注释要求：

  1. 对关键的算法实现代码有必要的注释
  2. 函数说明格式：

*****************************************************

函数名：

函数功能：

输入参数：

       类型，参数名，含义

输出参数：

       返回值，含义

文件提交要求：

将两道题目各自的完整工程（包含该工程下所有目录和文件）和此文档一起打包，以组内学生姓名作为文件名，上传提交。例如Stu1_Stu2.zip

代码:

LinkQueue.h

#pragma once
Status InitStack(Stack& S)//构造一个空栈 
{
	S.stack = (ElemType*)malloc(MaxSize * sizeof(ElemType));
	if (!S.stack) exit(OVERFLOW);
	S.top1 = -1;
	S.top2 = MaxSize;
	return OK;
}
/***************************
函数名：InitStack
函数功能：构造一个空栈
输入参数：Stack，S，栈
	   类型，参数名，含义
输出参数：Status，创建好的S栈
	   返回值，含义

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

Status Push(Stack& S, int k, ElemType e)//进栈。当k=1或2时对应向栈1或栈2的顶端插入元素e
{
	if (S.top1 == S.top2 - 1) {
		printf("存储空间已用完!\n");
		return ERROR;
	}

	if (k == 1) {
		S.top1++;
		S.stack[S.top1] = e;
	}
	else if (k == 2) {
		S.top2--;
		S.stack[S.top2] = e;
	}
	return OK;
}
/***************************
函数名：Push
函数功能：进栈。当k=1或2时对应向栈1或栈2的顶端插入元素e
输入参数：Stack，S,栈
          int，k,进栈位置
		  ElemType，e，进栈元素
	   类型，参数名，含义
输出参数：Status，创建好的S栈
	   返回值，含义

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

Status Pop(Stack& S, int k, ElemType& e)//出栈。若栈不为空，根据k的值删除栈1或栈2的栈顶元素，用e返回其值 
{
	if (k == 1) {
		if (S.top1 == -1) {
			return ERROR;
		}
		e = S.stack[S.top1];
		S.top1--;
		return OK;
	}

	else if (k == 2) {
		if (S.top2 == MaxSize) {
			return ERROR;
		}
		e = S.stack[S.top2];
		S.top2++;
		return OK;
	}

	else {

		printf("k的值不正确!");

		return ERROR;

	}

}
/***************************
函数名： Pop
函数功能：出栈。若栈不为空，根据k的值删除栈1或栈2的栈顶元素，用e返回其值
输入参数：Stack，S,栈
          int，k,出栈位置
		  ElemType，e，出栈元素
	   类型，参数名，含义
输出参数：Status，创建好的S栈
	   返回值，含义

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

Status InitQueue(LinkQueue& q)//构造一个空队列q  

{

	q.front = q.rear = (QueuePtr)malloc(sizeof(QNode));

	if (!q.front)  exit(OVERFLOW);

	q.front->next = NULL;

	return OK;

}
/***************************
函数名：InitQueue
函数功能：构造一个空队列q  
输入参数：LinkQueue，q，创建好的队列
	   类型，参数名，含义
输出参数：Status，创建好的q队列
	   返回值，含义

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

Status EnQueue(LinkQueue& q, ElemType e)//插入元素e为q的新的队尾元素  

{

	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));

	if (!p)

		exit(OVERFLOW);

	p->data = e;

	p->next = NULL;

	q.rear->next = p;

	q.rear = p;

	return OK;

}
/***************************
函数名：EnQueue
函数功能：插入元素e为q的新的队尾元素
输入参数：LinkQueue,q,插入的队列
          ElemType,e，插入的元素
	   类型，参数名，含义
输出参数：Status，创建好的q队列
	   返回值，含义
****************************/

Status DeQueue(LinkQueue& q, ElemType& e)//若队列不空，则删除q的队头元素，用e返回其值，并返回OK；否则返回ERROR  

{

	if (q.front == q.rear)

		return ERROR;

	QueuePtr  p;

	p = q.front->next;

	e = p->data;

	q.front->next = p->next;

	if (q.rear == p)

		q.rear = q.front;

	free(p);

	return OK;

}
/***************************
函数名：DeQueue
函数功能：若队列不空，则删除q的队头元素，用e返回其值，并返回OK；否则返回ERROR
输入参数：LinkQueue，q,等待被删除的队列
          ElemType，e，已经被删除的队头元素
	   类型，参数名，含义
输出参数：Status，创建好的q队列
	   返回值，含义

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

Status DestroyQueue(LinkQueue& q)//销毁队列q 

{

	while (q.front)

	{

		q.rear = q.front->next;

		free(q.front);

		q.front = q.rear;

	}

	return OK;

}
/***************************
函数名：DestroyQueue
函数功能：销毁队列q 
输入参数：LinkQueue，q，等待销毁的队列
	   类型，参数名，含义
输出参数：Status，创建好的q队列
	   返回值，含义

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

TRAIN.cpp

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

typedef char ElemType;
typedef int Status;

#define OK 1
#define ERROR 0
#define MaxSize 20
#define OVERFLOW -2 

struct Stack {

	ElemType* stack;

	int top1, top2;//表示栈顶元素的位置

}S;

typedef struct qNode

{

	char data;

	struct qNode* next;

} QNode, * QueuePtr;

typedef struct {

	QNode* front;//队头指针 

	QNode* rear;//队尾指针    

}LinkQueue;

#include "LinkQueue.h"

int main() {

	LinkQueue q;

	InitQueue(q);//构造一个空队列Q 

	InitStack(S);//构造一个空栈S 

	char a[100], e;

	int i = 0, m = 0, n = 0;//m表示字符'B'的个数,n表示字符'A'的个数

	printf("任意输入一串字符,其中A表示硬座，B表示硬卧，C表示软卧\n");

	scanf("%s", a);

	while (a[i] == 'A' || a[i] == 'B' || a[i] == 'C') {

		if (a[i] == 'B') {//字符'B'进入栈1 

			e = a[i];

			m++;

			Push(S, 1, a[i]);

		}

		if (a[i] == 'A') {//字符'A'进入栈2 

			e = a[i];

			n++;

			Push(S, 2, a[i]);

		}

		i++;

		if (m + n == MaxSize) {

			printf("共享栈存储空间已用完!\n");

			exit(0);

		}

		if (a[i] == 'C') {

			e = a[i];

			EnQueue(q, e);//字符'C'进队列 

		}

	}

	while (Pop(S, 1, e))//栈1中的元素依次出栈进队列 

		EnQueue(q, e);

	while (Pop(S, 2, e))//栈2中的元素依次出栈进队列 

		EnQueue(q, e);

	if (q.front == q.rear)//空队列  

		return 0;

	QueuePtr p = q.front->next;

	while (p != q.rear)  //非空队列 

	{

		printf("%c", p->data);

		p = p->next;

	}

	printf("%c", p->data);

	printf("\n");

	return 0;
}

loong luer
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言数据结构——栈和队列的实现
h2608011009的博客
05-13 262
文章目录前言栈Stack.hStack.c队列Queue.hQueue.c结束语 前言 本文章主要是为下一篇的在线OJ题目做铺垫，因为仅仅用c语言做栈与队列的OJ题时需要自己造轮子，也就是自己编写栈或者队列的前提下完成题目代码的编写。 栈（FIFO先进先出）的实现主要是用动态数组的形式构建，先进先出用数组再方便不过，只需要记录下标的值，初始为零，每次入栈加数据，下标加一，出栈的时候只需要将下标减一所对应的内容取出即可。 队列（FILO先进后出）的实现主要是用不带头循环的单链表的形式构建，注意需要记录头结点与
数据结构 - 栈和队列（C语言实现）
C橘子
04-13 7704
一. 栈 栈的定义  栈（Stack）是一种只能在一端进行插入或删除操作的线性表。                     图一 栈的示意图 顺序栈的基本操作   初始化 void InitStack(Stack *S){ //初始化顺序栈即使栈顶指针为-1 S->Top = -1; }   栈判空 int StackEmpty(Stack *S) { //栈判空函数...
数据结构：八种数据结构大全
热门推荐
緑水長流*z
07-29 20万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
数据结构(全)
s6664的博客
06-21 5万+
线性结构, 树形结构, 图结构, 排序, 查找, 数据结构, 算法
数据结构——双向链表
最新发布
quite123_的博客
07-07 174
双向链表与单链表基本相同，主要使考虑前驱与后继指针。
【数据结构基础笔记】【队列】
hanhan的博客
09-21 917
代码参考《妙趣横生的算法.C语言实现》 文章目录前言1、队列定义2、创建一个队列3、入队列4、出队列5、销毁一个队列6、循环队列的概念7、循环队列的实现8、实例分析 前言 本章总结：链队列定义，创建，出队入队操作，销毁操作；循环队列的定义以及循环队列的一些基本操作 1、队列定义 队列是一种先进先出的线性表(FIFO),它要求所有的数据从队列的一端进入，从队列的另一端离开。 在队列中，允许插入数据的一端角队尾，允许数据离开的一端叫做队头。 队列是一个线性表，既可以是一个顺序表也可以是一个链表。这里重点
C:\Users\20829\Desktop\test.cpp In function 'int main()': 28 9 C:\Users\20829\Desktop\test.cpp [Erro...
weixin_35749786的博客
02-16 1152
这是一个编译错误，意思是在文件路径为C:\Users\20829\Desktop\test.cpp的代码中，在main函数中的第289行出现了错误，错误信息为"continue statement not within a loop"，即"continue语句不在循环内"。这可能是因为在一个不是循环结构的代码块中使用了continue语句，而continue语句只能在循环结构中使用。要解决这个错误...
【数据结构】（一）数据结构入门
weixin_44378835的博客
11-06 1万+
文章目录数据结构入门1 数据结构基础知识2 算法复杂度 数据结构入门 数据结构+算法=程序数据结构+算法=程序数据结构+算法=程序 1 数据结构基础知识 数据 指所有能输入到计算机中的描述客观事物的符号，包括文本、声音、图像、符号等。 数据元素 数据元素是数据的基本单位，也称节点或记录，如下图所示。 数据项 数据项表示有独立含义的数据最小单位，也称域。若干个数据项构成一个数据元素，数据项是不可分割的最小单位，如上图所示的“86”。 数据对象 数据对象是指相同特性的数据元素的集合，是数据的一个子集。 数据结
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
C语言-数据结构-栈队列实现
03-10
这些文件共同构成了一个完整的C语言数据结构库，实现了栈和队列的基本操作，可以用于各种需要此类数据结构的计算机程序中。了解并熟练掌握这些基础知识对于任何想深入学习C语言或计算机科学的人来说都是至关重要的。
数据结构-C语言版：DS03-栈和队列.ppt
06-06
数据结构-C语言版：DS03-栈和队列.ppt
c语言数据结构-栈队列数组完美版资料.ppt
11-14
本资源摘要信息主要关于C语言数据结构中的栈、队列和数组三个基本概念。...栈、队列和数组是C语言数据结构中的三个基本概念，栈的实现需要考虑到实际情况，栈的应用非常广泛，栈的优点和缺点需要被正确地考虑。
构造一个空队列的c语言语句,数据结构（C语言版）-第3章 栈和队列
weixin_39796868的博客
05-21 1614
3.1 栈和队列的定义和特点3.2 案例引入3.3 栈的表示和操作的实现3.4 栈与递归3.5 队列的的表示和操作的实现3.6 案例分析与实现 基本操作有入栈、出栈、读栈顶元素值、建栈、判断栈满、栈空等队列是一种先进先出(FIFO) 的线性表. 在表一端插入,在另一端删除 顺序栈的表示 顺序栈的定义：#define MAXSIZE 100typedefstruct{SElemTyp...
常见的数据结构总结（8种）
m0_60416282的博客
07-05 2万+
1. 顺序表（数组 Array）2. 链表 3. 栈（Stack）4. 队列（Queue）5. 树（Tree）6. 堆（Heap）7. 图（graph）8. 散列表（Hash）
3.4队列
IT1995的博客
02-03 4474
3.4队列
数据结构 链式队列
初学者的博客
07-07 243
链式队列实现
数据结构——队列（C语言实现）
sinzz的博客
04-16 3027
首先，我们需要定义的是链式结构的队列，即单链表为底层实现的。所以需要定义单链表结构来存储数据。然后，定义队列，队列里需要定义两个指向单链表的指针，一个是指向单链表头结点的指针，另一个则用来保存尾结点地址的指针。最后，还需定义一个记录当前队列元素个数的变量，用于遍历队列和判空。int size;} Queue;
C语言--队列的创建及使用详解
2301_77637225的博客
11-25 2561
队列结构是一种变相的链表结构，相比于单独的链表，它多了一个包含队头指针和队尾指针的结构体，但其实质上，仍旧属于链表结构。只要掌握了链表结构，队列结构的实现会变得比较简单。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值