数据结构（C语言严蔚敏版）——第三章 栈和队列

最新推荐文章于 2024-08-08 15:24:54 发布
最新推荐文章于 2024-08-08 15:24:54 发布
阅读量2.1k 收藏 19
点赞数 17
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80818909/article/details/139720079
版权

3.1 栈

3.1.1 抽象数据类型栈的定义

栈（stack）：是限定仅在表尾进行插入或删除操作的线性表。

因此，对栈来说，表尾端有其特殊含义，称为栈顶（top），相应地，表头端称为栈底（bottom）。不含元素的空表称为空栈。

3.1.2 栈的表示和实现

和线性表类似，栈也有两种存储表示方式。

栈可以用数组和链表实现，但两者确各有千秋。

数组栈：

        顾名思义，由数组开辟空间所得到的顺序结构，开辟的空间具有连续性的特点。因为这个特点，所以数组栈可以随机访问，读取的效率高。但是，我们需要思考一个问题，数组栈就没有缺点吗？如果没有，那么为什么又会存在链栈这一概念？其实这两者最大的区别在于读取效率和空间利用。数组栈的读取效率高，但是当我存放一个不知道空间大小的东西在栈里面，那么我的数组空间应该开辟多大？显然，数组栈的空间开辟是具有不确定性的，如果空间不够，可能会造成数组越界等情况。而如果数组空间开辟过大就会造成空间的利用率低，浪费内存的情况。

链栈：

   运用链表的方式为栈开辟空间，这样可以极大的节省空间，我存入一个数据，那么我就开辟一个数组的空间。这种创建栈的方式非常有利于那种对于存储空间要求高的编程性工作上，例如嵌入式等对于空间的要求就很高。但是，这种链表方式创建的栈相较于数组栈来说，它获取栈元素会更麻烦，每次获取对栈中的某一个操作我都需要去遍历，依次来找到我所要操作的元素，这也是链栈的不利之处。

栈是一种特殊的顺序结构，它的特点在于后进先出，这个特点在以后的工作或者学习中能够起到很大的作用。

对于栈的创建，以下代码选择了链栈方式

1、栈的创建（栈的初始化）

struct Node
{
    int data;
    struct Node* next;
};
struct stack
{
    struct Node* stackTop;//栈顶标记
    int size;//栈中的元素个数
};
//创建结点
struct Node* createNode(int data)
{
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
//创建栈，就是创建一个struct stack的变量
struct stack* createStack(){
    //创建过程就是初始化过程
    struct stack* myStack = (struct stack*)malloc(sizeof(struct stack));
    myStack->stackTop = NULL;
    myStack->size = 0;
    return myStack;
}

2、入栈

//入栈操作
void push(struct stack* myStack,int data)
{
    //插入的这个结点创建出来
    struct Node* newNode = createNode(data);
    //入栈操作就是链表表头的插入
    newNode->next = myStack->stackTop;
    myStack->stackTop = newNode;
    myStack->size++;
}

3、获取栈顶元素

//获取栈顶元素
int top(struct stack* myStack)
{
    if(myStack->size == 0)
    {
        //防御性编程
        printf("栈为NULL,无法获取栈顶元素！\n");
        system("pause");//防止闪屏
        return myStack->size;
    }
    return myStack->stackTop->data;
}

4、出栈（删除结点）

//出栈（即删除结点）
void pop(struct stack* myStack)
{
    if(myStack->size == 0)
    {
        printf("栈为NULL,无法出栈！\n");
        system("pause");
    }
    else
    {
        struct Node* nextNode = myStack->stackTop->next;
        free(myStack->stacTop);
        myStack->stackTop = nextNode;
        myStack->size--;
    }   
}

5、判空

//判空
int empty(struct stack* myStack)
{
    if(myStack->size == 0)
    {
        return 0;
    }
    return 1;    
}

链栈总代码

#include<stdio.h>
#include<stdlib.h>
struct Node
{
    int data;
    struct Node* next;

};

//创建结点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
struct stack
{
    struct Node* stackTop;//栈顶标记
    int size;//栈中的元素个数 
};
//创建栈，就是创建一个struct stack的变量
struct stack* createStack() {
    //创建过程就是初始化过程
    struct stack* myStack = (struct stack*)malloc(sizeof(struct stack));
    myStack->stackTop = NULL;
    myStack->size = 0;
    return myStack;
}
//入栈操作
void push(struct stack* myStack, int data)
{
    //插入的这个结点创建出来
    struct Node* newNode = createNode(data);
    //入栈操作就是链表表头插入
    newNode->next = myStack->stackTop;
    myStack->stackTop = newNode;
    myStack->size++;
}
//获取栈顶元素
int top(struct stack* myStack)
{
    //防御性编程
    if (myStack->size == 0)
    {
        printf("栈为NULL,无法获取栈顶元素！\n");
        system("pause");
        return myStack->size;
    }
    return myStack->stackTop->data;
}
//出栈（即删除结点）
void pop(struct stack* myStack)
{
    if (myStack->size == 0)//防御性编程
    {
        printf("栈为NULL，无法出栈！\n");
        system("pause");
    }
    else
    {
        struct Node* nextNode = myStack->stackTop->next;
        free(myStack->stackTop);
        myStack->stackTop = nextNode;
        myStack->size--;
    }
}
//（判空）
int empty(struct stack* myStack)
{
    if (myStack->size == 0) {
        return 0;
    }
    return 1;
}

int main()
{
    struct stack* myStack = createStack();
    push(myStack, 1);
    push(myStack, 2);
    push(myStack, 3);
    while (empty(myStack))//如果栈为空，则empty函数返回0，循环结束
    {
        printf("%d\t", top(myStack));
        pop(myStack);
    }
    printf("\n");
    system("pause");//防止闪屏
    return 0;
}

3.2 队列

3.2.1 抽象数据类型队列的定义

和栈相反，队列（queue）是一种先进先出（first in first out ，缩写为FIFO）的线性表。它只允许在表的一端进行插入，而在另一端删除元素。

在队列中，允许插入的一端叫做队尾（rear)，允许删除的一端则称为队头（front）。

3.2.2 链队列——队列的链式表示和实现

类比于栈，队列同样可以使用数组或者链表实现队列，这两者最大区别在于栈是先进后出，队列是先进先出。那么我在此提出两个值得思考的问题，问题一：链栈和数组栈各有优缺点，链队列和数组队列中有何突出的区别，哪种方式实现数组的方式更好？问题二：队列的特点是先进先出，即头出尾进。那么数组队列是否可以尾进头出？链队列呢？如果可以，是为什么，如果不可以，那又是为什么？

（大家可以先结合以下的代码重点思考第二个问题，问题一的答案是链队列更好，至于为什么，其实跟问题二的答案是一样的，我会将答案在最后公布）

1、队列创建前的准备

struct Node
{
	int data;
	struct Node* next;
};
/*创建队列结点*/
struct Node* createNode(int data)
{
	struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
	newNode->data = data;
	newNode->next = NULL;
	return newNode;
}
struct Queue
{
	struct Node* frontNode;//指向队头的指针
	struct Node* tailNode;//指向队尾的指针
	int size;//队列的长度
};

2、创建队列

struct Queue* createQueue()
{
	struct Queue* myQueue = (struct Queue*)malloc(sizeof(struct Queue));
	myQueue->frontNode = myQueue->tailNode = NULL;
	myQueue->size = 0;
	return myQueue;
}
/*在一开始，队列是空的，所以我们需要将队头指针与队尾指针放在一起*/

3、入列

void push(struct Queue* myQueue, int data)
{
	struct Node* newNode = createNode(data);
	if (myQueue->size == 0)
	{
		myQueue->frontNode = myQueue->tailNode = newNode;
	}
	else
	{
		myQueue->tailNode->next = newNode;
		myQueue->tailNode = newNode;
	}
	myQueue->size++;
}

3、获取栈顶元素

int front(struct Queue* myQueue)
{
	if (myQueue->size == 0)
	{
		printf("队为NULL，无法获取队头元素！\n");
		system("pause");//暂停窗口
		return myQueue->size;
	}
	return myQueue->frontNode->data;
}

 4、出队

void pop(struct Queue* myQueue)
{
    if(myQueue->size == 0{
        printf("队为NULL，无法出队！\n);
        system("pause");
        return;
    }
    else
	{
		struct Node* nextNode = myQueue->frontNode->next;
		free(myQueue->frontNode);
		myQueue->frontNode = nextNode;
		myQueue->size--;
	}
}

5、判空

int empty(struct Queue* myQueue)
{
	if (myQueue->size == 0)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

链队列总代码

#include<stdio.h>
#include<stdlib.h>
struct Node
{
	int data;
	struct Node* next;
};
//创建结点
struct Node* createNode(int data)
{
	struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
	newNode->data = data;
	newNode->next = NULL;
	return newNode;
}

struct Queue
{
	struct Node* frontNode;//队头指针
	struct Node* tailNode;//队尾指针
	int size;//队列的长度
};
//创建队列
struct Queue* createQueue()
{
	struct Queue* myQueue = (struct Queue*)malloc(sizeof(struct Queue));
	myQueue->frontNode = myQueue->tailNode = NULL;
	myQueue->size = 0;
	return myQueue;
}
 
//STL  封装很多的容器  stack 和 queue
//入队
void push(struct Queue* myQueue, int data)
{
	struct Node* newNode = createNode(data);
	if (myQueue->size == 0)
	{
		myQueue->frontNode = myQueue->tailNode = newNode;
        //当队列为空时，队头指针与队尾指针在同一个结点上
	}
	else
	{
		myQueue->tailNode->next = newNode;
		myQueue->tailNode = newNode;
	}
	myQueue->size++;
}

//出队
void pop(struct Queue* myQueue)
{
	if (myQueue->size == 0) {
		printf("队为NULL，无法出队！\n");
		system("pause");
		return;
	}
	else
	{
		struct Node* nextNode = myQueue->frontNode->next;
		free(myQueue->frontNode);
		myQueue->frontNode = nextNode;
		myQueue->size--;
	}
}

//获取队头元素
int front(struct Queue* myQueue)
{
	if (myQueue->size == 0)
	{
		printf("队为NULL，无法获取队头元素！\n");
		system("pause");
		return myQueue->size;
	}
	return myQueue->frontNode->data;
}

//判空
int empty(struct Queue* myQueue)
{
	if (myQueue->size == 0)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}
int main() {
	//创建队列
	struct Queue* myQueue = createQueue();
	//入队
	push(myQueue, 1);
	push(myQueue, 2);
	push(myQueue, 3);
	//获取队列元素
	while (empty(myQueue))
	{
		printf("%d\t", front(myQueue));
		pop(myQueue);
	}
	printf("\n");
	system("pause");
	return 0;
}
好的，那我们现在回到问题二，不知道大家的想法是否跟我一样。我的想法是：一般情况下，链队列会比数组队列常用一点，数组队列不可以实现头进尾出，而链队列可以。因为我们需要注意一个很重要的点，数组分配的空间是连续的，而链表分配的空间是不连续。想要实现头进尾出，无非就是将队头指针当作队尾指针来用，队尾指针当作队头指针用，那么链表可以在头结点处加结点，新加的结点成为头结点，但是数组比如a[0]前面可以加a[-1]、a[-2]吗？。很显然这是不行的。

3.2.3 循环队列——队列的顺序表示和实现

循环队列的特点：

1、元素在队尾插入，在队头删除，遵循先进先出原则

2、在C语言中不能用动态分配的一堆数组来实现循环队列。如果用户的应用程序中设有循环队列，则必须为它设定一个最大队列长度；若用户无法预估所用队列最大长度，则宜采用链队列。由于循环队列基于数组实现，所以它的访问速度很快，特别是在移动元素时。

3、相比普通的队列，循环队列在元素出队时无需移动大量元素，只需移动头指针。

4、循环队列的优点在于可以更有效地利用存储空间，并解决因数组越界而产生的假溢出问题。

1、定义队列结构

#define MAX_SIZE 5  //宏定义队列能存放的元素的最大个数，数组的长度

typedef struct {

    int data[MAX_SIZE];//保存数据的数组

    int front;//保存队头元素下标的队头指针
    int rear;//保存队尾元素下标的队尾指针
}Queue;

2、初始化，只要用初始化队头指针和队尾指针

void initQueue(Queue* q) {
    q->front = 0;//初始化队头指针
    q->rear = 0;//初始化队尾指针
}

3、判断队空

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

4、判断队满

int isFull(Queue* q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

5、元素入队

void push(Queue* q, int val) {
    //如果队满，不能入队
    if (isFull(q)) {
        printf("队满，无法入队！\n");
        return;
    }
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->data[q->rear] = val;
}

6、元素出队

int pop(Queue* q) {
    //如果队空，不能出队
    if (isEmpty(q)) {
        printf("队空，不能出队");
        return -1;
    }
   
    q->front = (q->front + 1) % MAX_SIZE;
    int temp = q->data[q->front];
    return temp;
}

7、获取队头元素

int getFront(Queue* q) {
    if (isEmpty(q)) {
        printf("队空，无元素\n");
    }
    int temp = q->front + 1;
    return q->data[temp];
}

8、获取队尾元素

int getRear(Queue* q) {
    if (isEmpty(q)) {
        printf("队空，无元素\n");
        return -1;
    }
    return q->data[q->rear];
}

总代码

#include<stdio.h>

#define MAX_SIZE 5  //队列能存放的元素的最大个数，数组的长度

//定义队列结构
typedef struct {

    int data[MAX_SIZE];//保存数据的数组

    int front;//保存队头元素下标的队头指针
    int rear;//保存队尾元素下标的队尾指针
}Queue;

//初始化，只用初始化队头指针和队尾指针
void initQueue(Queue* q) {
    q->front = 0;
    q->rear = 0;
}

//判断队空
int isEmpty(Queue* q) {
    return q->front == q->rear;
}

//判断队满
int isFull(Queue* q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

//元素入队
void push(Queue* q, int val) {
    //如果队满，不能入队
    if (isFull(q)) {
        printf("队满，无法入队！\n");
        return;
    }
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->data[q->rear] = val;
}

//元素出队
int pop(Queue* q) {
    //如果队空，不能出队
    if (isEmpty(q)) {
        printf("队空，不能出队");
        return -1;
    }
   
    q->front = (q->front + 1) % MAX_SIZE;
    int temp = q->data[q->front];
    return temp;
}

//获取队头元素
int getFront(Queue* q) {
    if (isEmpty(q)) {
        printf("队空，无元素\n");
    }
    int temp = q->front + 1;
    return q->data[temp];
}

//获取队尾元素
int getRear(Queue* q) {
    if (isEmpty(q)) {
        printf("队空，无元素\n");
        return -1;
    }
    return q->data[q->rear];
}



int main() {
    //定义一个队列
    Queue q;
    //初始化队列
    initQueue(&q);
    //依次入队4个元素
    push(&q, 10);
    push(&q, 20);
    push(&q, 30);
    push(&q, 40);
    //弹出两个元素 10，20
    printf("%d ", pop(&q));
    printf("%d \n", pop(&q));
    //再插入两个
    push(&q, 50);
    push(&q, 60);
    //将所有元素出队
    // 30 40 50
    printf("%d ", pop(&q));
    printf("%d ", pop(&q));
    printf("%d ", pop(&q));
    printf("%d \n", pop(&q));
    //-1 提示队空
    printf("%d ", pop(&q));
    return 0;
}

风在窗边
关注
  • 17
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
数据结构（C语言版）(第2版) —— 严蔚敏 李冬梅 吴伟民.zip
06-14
《数据结构（C语言版）(第2版)》是由严蔚敏、李冬梅、吴伟民三位专家编著的经典教材，对于学习C语言和深入理解数据结构的初学者而言，这是一份不可多得的资源。这本书以其清晰的理论阐述和丰富的实践示例，帮助读者...
严蔚敏 数据结构(C语言版) 代码 23490 书中算法
04-21
第3章　栈和队列　44 3.1　栈　44 3.1.1　栈的类型定义　44 3.1.2　顺序栈的表示和实现　45 3.1.3　链栈的表示和实现　47 3.2　栈的应用　48 3.2.1　数制转换　49 3.2.2　括号匹配的检验　49 3.2.3　表达式求值　51 ...
数据结构严蔚敏版精简版-栈和队列以及c语言代码实现
qq_37040743的博客
06-09 510
和栈相反，队列(queue)是一种先进先出(First In First Out, FIFO)的线性表。它只允许在表 的一端进行插入，而在另一端删除元素。如果入队序列为1，2，3，4出队序列也为1，2，3，4队列在程序设计中也经常出现。一个最典型的 例子就是操作系统中的作业排队。在允许多道程序 运行的计算机系统中，同时有几个作业运行。如果运行的结果都需要通过通道输出，那就要按请求 输入的先后次序排队。每当通道传输完毕可以接受新的输出任务时，队头的作业先从队列中退出 做输出操作。
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
chongyang_的博客
11-07 26万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
《数据结构 C语言版 严蔚敏 第2版》：栈和队列
秋玄的博客
10-28 297
栈和队列（顺序栈、链栈；循环队列、链队）
数据结构：栈和队列(Stack & Queue)【详解】
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构（严蔚敏版）第三章——栈和队列（三）【队列的表示和操作的实现】
java小豪的博客
10-17 583
队列（Queue）是仅在表尾进行插入操作，在表头进行删除操作的线性表 表尾即an端，称为队尾；表头即a1端，称为队头。它是一种先进先出(FIFO)的线性表；插入元素称为入队；删除元素称为出队、队列的存储结构为链队或顺序 3.4、栈与递归 3.4.1、采用递归算法解决的问题 3.5、队列的表示和操作的实现 3.5.1、相关术语 3.5.2、队列的相关概念 3.5.3、队列的类型定义 3.5.4、队列的顺序表示和实现 3.5.5、队列的链式表示和实现
【最详细】数据结构（C语言版 第2版）第三章课后习题答案 严蔚敏 等 编著
weixin_43899069的博客
11-01 5万+
1．选择题 （ 1）若让元素 1， 2， 3， 4， 5 依次进栈，则出栈次序不可能出现在（）种情况。 A． 5， 4， 3， 2， 1 B． 2， 1， 5， 4， 3 C． 4， 3， 1， 2， 5 D． 2， 3， 5， 4， 1 答案： C 解释：栈是后进先出的线性表，不难发现 C 选项中元素 1 比元素 2 先出栈，违背了栈 的后进先出原则，所以不可能出现 C 选项所示的情况。 （ 2）若已知一个栈的入栈序列是 1，2，3，, ， n，其输出序列为 p1，p2，p3 ，, ， pn， 若 p1=
数据结构（C语言版）严蔚敏 吴伟民 编著 第3章 栈和队列
小成星际的博客
02-17 552
数据结构（C语言版）严蔚敏 吴伟民 编著 第3章 栈和队列前言3.1 栈3.1.1 抽象数据类型栈的定义3.1.2 栈的表示和实现3.2 栈的应用举例3.2.1 数制转换3.2.2 括号匹配的检验3.2.3 行编辑程序3.2.4 迷宫求解3.2.5 表达式求值3.3 栈与递归的实现3.4 队列3.4.1 抽象数据类型队列的定义3.4.2 链队列——队列的链式表示和实现3.4.3 循环队列——队列的顺序表示和实现 前言 栈和队列是两种重要的线性结构，从数据结构角度看，栈和队列也是线性表，其特殊性在于栈和队列的
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 41万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
队列——数据结构严蔚敏C语言版
zt的博客
03-28 1339
文章目录队列的定义环形队列循环队列的基本操作链队链队的基本操作 队列的定义 队列(Queue):先进先出的线性表 队列是仅在队尾进行插入和队头进行删除操作的线性表 队头(front)：线性表的表头端,即可删除端 队尾(rear)：线性表的表尾端,即可插入端 由于这种队列存在假溢出现象,所以引入了循环链表解决假溢出想象 什么是假溢出可参考这篇文章 环形队列 区别环形队列是满队还是空队的两种方式 另设一个标志以区别队列是满队还是空队 少用一个元素空间 队空的条件：Q.front == Q.rear
数据结构：第3章栈和队列B.ppt
06-12
在本章中，我们将重点讨论两种重要的数据结构——栈和队列。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，它的主要特点是只能在一端进行插入和删除操作，通常称为栈顶。栈在计算机科学中有多种应用，...
数据结构（C语言版） 严蔚敏 吴伟民 编著 电子版课件
06-03
《数据结构（C语言版）》是由著名计算机科学家严蔚敏和吴伟民编著的经典教材，本教材以C语言为实现工具，深入浅出地介绍了各种典型的数据结构及其算法。 第一章通常会介绍数据结构的基本概念，包括数据、数据元素、...
【数据结构-前缀哈希】力扣523. 连续的子数组和
sjsjs11的博客
08-05 364
当发现有两个余数相同的key的时候，对他们value作差，如果大于等于二，说明该子段长度大于等于二，这时候就找到了一个好的子数组，返回true，如果到最后都没有找到这样一个好的子数组，返回false。，其中 m 是数组 nums 的长度。解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42。输入：nums = [23,2,6,4,7], k = 13。输入：nums = [23,2,4,6,7], k = 6。输入：nums = [23,2,6,4,7], k = 6。
常见8种数据结构
最新发布
qq_43575301的博客
08-08 662
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
数据结构：栈（含源码）
2401_86551514的博客
08-05 577
先判断容量是否有足够的空间让数据入栈，在第一次入栈是先给定4个空间，后面每次不够时就将空间数乘以2， 还有一个判断是否开辟成功（这个可以不写，一般都会开辟成功）。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出的原则。我们在创建栈时，一般是创建支持动态增长的栈，定长的静态栈不实用。出栈非常的简单，只要将top数减少一个就行了，相当于是下一次入栈是直接把这个数据修改掉，就算没修改，打印时也不影响。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值