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

最新推荐文章于 2026-03-24 07:55:20 发布
原创 最新推荐文章于 2026-03-24 07:55:20 发布 · 718 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#算法 #数据结构 #c语言
文章是关于C++编程的实验报告，涉及栈和队列的基本操作，如创建、入栈、出栈、遍历等，并展示了如何使用栈和队列来模拟火车车厢的调度，即按特定规则重新排列车厢。作者在实验中遇到了C++使用不熟练的问题，通过学习和实践得以解决。

第一次上机实验报告

作业题目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
关注
数据结构：八种数据结构大全
热门推荐
緑水長流*z
07-29 24万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
数据结构(全)
s6664的博客
06-21 10万+
线性结构, 树形结构, 图结构, 排序, 查找, 数据结构, 算法
数据结构从0到入门（1）：数据结构概述
最新发布
陌然的博客
03-24 340
通过本系列文章的学习，我们将逐步掌握各种数据结构的原理、实现和应用，为后续的算法学习打下坚实的基础。数据结构是计算机存储、组织数据的方式，是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构是算法的基础，算法是操作数据结构的方法。好的算法需要合适的数据结构来支持，而好的数据结构也需要高效的算法来操作。空间复杂度是指算法执行所需的额外空间随输入规模增长的趋势，同样用大O表示法表示。在接下来的章节中，我们将从数组开始，逐步深入学习各种数据结构的实现和应用。：适合需要层次结构的场景（将在第8章详细介绍）
【数据结构基础笔记】【队列】
hanhan的博客
09-21 1269
代码参考《妙趣横生的算法.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 1515
这是一个编译错误，意思是在文件路径为C:\Users\20829\Desktop\test.cpp的代码中，在main函数中的第289行出现了错误，错误信息为"continue statement not within a loop"，即"continue语句不在循环内"。这可能是因为在一个不是循环结构的代码块中使用了continue语句，而continue语句只能在循环结构中使用。要解决这个错误...
构造一个空队列的c语言语句,数据结构（C语言版）-第3章 栈和队列
weixin_39796868的博客
05-21 1811
3.1 栈和队列的定义和特点3.2 案例引入3.3 栈的表示和操作的实现3.4 栈与递归3.5 队列的的表示和操作的实现3.6 案例分析与实现 基本操作有入栈、出栈、读栈顶元素值、建栈、判断栈满、栈空等队列是一种先进先出(FIFO) 的线性表. 在表一端插入,在另一端删除 顺序栈的表示 顺序栈的定义：#define MAXSIZE 100typedefstruct{SElemTyp...
C语言链表实现队列和栈：探索数据结构的灵活运用
ByteBox的博客
12-07 534
/ 链表节点定义int data;通过本文的学习，读者深入理解了如何使用链表实现队列和栈，这两种数据结构在算法和程序设计中都具有重要的应用。链表作为底层数据结构，为队列和栈提供了灵活的内存分配和元素操作方式。希望这篇教程对读者在C语言中学习和应用队列和栈时有所帮助。
数据结构：栈和队列的实现附上源代码（C语言版）
2301_79171011的博客
02-27 1527
这篇文章是关于栈和队列的C语言实现，干货满满，大家可以边看边手写代码，最后附上栈和队列的参考代码。栈和队列的实现其实相较于链表的实现简单一些，是因为其结构的特殊要求。之后会出一篇关于栈和队列的OJ题目。多多重复，百炼成钢！创作不易，希望这篇文章能给你带来启发和帮助，如果喜欢这篇文章，请留下你的三连，你的支持的我最大的动力！！！
C语言数据结构详解：数组、链表、栈、队列、树和图等的设计与实现
科技改变人类，技术成就未来
02-27 1583
数据结构是计算机科学中的基本概念，用于组织和存储数据，以便高效地进行访问和修改。常见的数据结构包括数组、链表、栈、队列、树和图等。本文将介绍几种常见的数据结构及其在C语言中的实现。
【数据结构初阶】：栈和队列的实现（用C语言实现，附图详解和附源码）
平凡的指针的博客
11-01 1505
文章目录栈的实现：一、栈的概念和性质二、栈的实现思路三、栈的相关变量内存布局图四、栈的初始化和销毁五、栈的接口实现：1.入栈2.出栈3.获取栈顶的数据4.获取栈的元素个数5.判断栈是否为空队列的实现：一、队列的概念和性质二、队列的实现思路三、队列相关变量的内存布局图四、队列的初始化和销毁五、队列的接口实现：1. 入数据2.出数据3.取队头数据4.取队尾数据5.获取队列元素个数6.判断队列是否为空总结 栈的实现： 一、栈的概念和性质 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在固定的一端进行插
【数据结构】（一）数据结构入门
weixin_44378835的博客
11-06 1万+
文章目录数据结构入门1 数据结构基础知识2 算法复杂度 数据结构入门 数据结构+算法=程序数据结构+算法=程序数据结构+算法=程序 1 数据结构基础知识 数据 指所有能输入到计算机中的描述客观事物的符号，包括文本、声音、图像、符号等。 数据元素 数据元素是数据的基本单位，也称节点或记录，如下图所示。 数据项 数据项表示有独立含义的数据最小单位，也称域。若干个数据项构成一个数据元素，数据项是不可分割的最小单位，如上图所示的“86”。 数据对象 数据对象是指相同特性的数据元素的集合，是数据的一个子集。 数据结
常见的数据结构总结（8种）
m0_60416282的博客
07-05 2万+
1. 顺序表（数组 Array）2. 链表 3. 栈（Stack）4. 队列（Queue）5. 树（Tree）6. 堆（Heap）7. 图（graph）8. 散列表（Hash）
数据结构 链式队列
初学者的博客
07-07 530
链式队列实现
3.4队列
IT1995的博客
02-03 4793
3.4队列
数据结构——队列（C语言实现）
sinzz的博客
04-16 3717
首先，我们需要定义的是链式结构的队列，即单链表为底层实现的。所以需要定义单链表结构来存储数据。然后，定义队列，队列里需要定义两个指向单链表的指针，一个是指向单链表头结点的指针，另一个则用来保存尾结点地址的指针。最后，还需定义一个记录当前队列元素个数的变量，用于遍历队列和判空。int size;} Queue;
C语言--队列的创建及使用详解
2301_77637225的博客
11-25 3331
队列结构是一种变相的链表结构，相比于单独的链表，它多了一个包含队头指针和队尾指针的结构体，但其实质上，仍旧属于链表结构。只要掌握了链表结构，队列结构的实现会变得比较简单。
【数据结构】八种常见数据结构介绍
非晚非晚的博客
02-05 6万+
数据结构是计算机存储、组织数据的方式。一种好的数据结构可以带来更高的运行或者存储效率。数据在内存中是呈线性排列的，但是我们可以使用指针等道具，构造出类似“树形”的复杂结构。下面介绍八个常见的数据结构。
数据结构：八大数据结构分类
JavaAlliance
09-14 4553
数据结构：八大数据结构分类 数据结构分类 数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 。 常用的数据结构有：数组，栈，链表，队列，树，图，堆，散列表等，如图所示： 每一种数据结构都有着独特的数据存储方式，下面为大家介绍它们的结构和优缺点。 1、数组 数组是可以在内存中连续存储多个元素的结构，在内存中的分配也是连续的，数组中的元素通过数组下标进行访问，...
DS博客作业03--栈和队列
weixin_30732487的博客
04-15 1336
1.本周学习总结 1.通过学习栈，我知道了栈是一种基本运算受限的线性表，只允许从栈顶一端进行操作，另一端为栈底（就比如在生活中叠盘子，第一个放上去的为栈底，最后一个放上去的为栈顶），栈顶是动态的，入栈出栈就是在栈中添加或删除一个数据，随着栈顶也跟着变化，由于这种操作受限，栈也遵循“先进后出”的原则。 2.队列也是一种操作受限的线性表，只允许在队列的队头进行删除操作（出队），在队尾进行添加操作（入队...
C语言数据结构：栈和队列
qq_42319810的博客
07-02 2819
define MaxSzie 10 //定义栈中元素的最大个数//静态数组存放栈中元素int top;//栈顶指针}SqStack;//初始化栈S.top = -1;//初始化栈顶指针SqStack S;//声明一个顺序栈（分配空间）.....//判空操作else//数据域//指针域}*LiStack;//栈类型定义队列（Queue）是只允许在一端进行插入，在另一端删除的线性表重要术语：队头、队尾、空队列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值