数据结构（学习）2024.8.8（栈，队列）

于 2024-08-08 20:10:55 发布
阅读量469 收藏 6
点赞数 19
文章标签： 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60450758/article/details/141029042
版权

今天学习的是线性表里面的栈和队列

链表的相关知识可以查看http://t.csdnimg.cn/NX464

顺序表的相关知识可以查看http://t.csdnimg.cn/5IMAZ

目录

栈

栈的定义

栈的特点

顺序栈

结构体

顺序栈的相关操作案例

链式栈

结构体

链式栈的相关操作案例

总结

队列

队列的定义

队列的特点

顺序队列(又称为循环队列)

结构体

顺序队列的相关操作案例

链式队列 

结构体

链式队列的相关操作案例

栈

栈的定义

        只能在一端进行插入和删除操作的线性表（又称为堆栈），进行插入和删除操作的一端称为栈顶，另一端称为栈底。

栈的特点

先进后出 FILO first in last out   LIFO

顺序栈

1.逻辑结构：线性结构
2.存储结构：顺序存储
3.操作：入栈、出栈

结构体

typedef struct seqstack
{
    int *data;  // 指向栈的存储位置
    int maxlen; // 保存栈的最大长度
    int top;    // 称为栈针，用的时候，心里面可以将按照顺序表里的last来使用， top 始终代表当前栈内最后一个有效元素的下标
} seqstack_t;

顺序栈的相关操作案例

头文件seqstack.h:

#ifndef _SEQSTACK_H_
#define _SEQSTACK_H_
#include <stdio.h>
#include <stdlib.h>
typedef struct seqstack
{
    int *data;  // 指向栈的存储位置
    int maxlen; // 保存栈的最大长度
    int top;    // 称为栈针，用的时候，心里面可以将按照顺序表里的last来使用
             // top 始终代表当前栈内最后一个有效元素的下标
} seqstack_t;
// 1.创建一个空的栈
seqstack_t *CreateEpSeqStack(int len); // len代表的是创建栈的时候的最大长度
// 2.判断是否为满,满返回1 未满返回0
int IsFullSeqStack(seqstack_t *p);
// 3.入栈
int PushStack(seqstack_t *p, int data); // data代表入栈的数据
// 4.判断栈是否为空
int IsEpSeqStack(seqstack_t *p);
// 5.出栈
int PopSeqStack(seqstack_t *p);
// 6. 清空栈
void ClearSeqStack(seqstack_t *p);
// 7. 获取栈顶数据(注意不是出栈操作，如果出栈，相当于删除了栈顶数据，只是将栈顶的数据获取到，不需要移动栈针)
int GetTopSeqStack(seqstack_t *p);
// 8. 求栈的长度
int LengthSeqStack(seqstack_t *p);
#endif

顺序栈函数seqstack.c:

#include "seqstack.h"

// 1.创建一个空的栈
seqstack_t *CreateEpSeqStack(int len) // len代表的是创建栈的时候的最大长度
{
    // 1.开辟一个结构体类型大小的空间
    seqstack_t *p = (seqstack_t *)malloc(sizeof(seqstack_t));
    if (p == NULL)
    {
        perror("CreateEpSeqStack函数创建结构体失败");
        return NULL;
    }

    // 2.初始化
    p->top = -1;
    p->maxlen = len;
    p->data = (int *)malloc(len * sizeof(int));
    if (p->data == NULL)
    {
        perror("CreateEpSeqStack函数创建数据空间失败");
        free(p);
        p = NULL;
        return NULL;
    }
    return p;
}

// 2.判断是否为满,满返回1 未满返回0
int IsFullSeqStack(seqstack_t *p)
{
    return p->top == p->maxlen - 1;
}

// 3.入栈
int PushStack(seqstack_t *p, int data) // data代表入栈的数据
{
    // 1.容错判断(判满)
    if (IsFullSeqStack(p))
    {
        perror("PushStack函数出错\n");
        return -1;
    }

    // 2.移动指针
    p->top++;

    // 3.入栈
    p->data[p->top] = data;

    return 0;
}

// 4.判断栈是否为空
int IsEpSeqStack(seqstack_t *p)
{
    return p->top == -1;
}

// 5.出栈
int PopSeqStack(seqstack_t *p)
{
    // 1.容错判断(判空)
    if (IsEpSeqStack(p))
    {
        perror("PopSeqStack函数出错\n");
        return -1;
    }

    // 2.移动指针
    p->top--;

    // 3.出栈数据
    return p->data[p->top + 1];
}

// 6. 清空栈
void ClearSeqStack(seqstack_t *p)
{
    p->top = -1;
}

// 7. 获取栈顶数据(注意不是出栈操作，如果出栈，相当于删除了栈顶数据，只是将栈顶的数据获取到，不需要移动栈针)
int GetTopSeqStack(seqstack_t *p)
{
    while (!IsEpSeqStack(p))
    {
        return p->data[p->top];
    }
    return -1;
}

// 8. 求栈的长度
int LengthSeqStack(seqstack_t *p)
{
    return p->top + 1;
}

主函数main.c:

#include "seqstack.h"

int main(int argc, char const *argv[])
{
    int data;
    seqstack_t *p = CreateEpSeqStack(5);

    PushStack(p, 1);
    PushStack(p, 2);
    PushStack(p, 3);
    printf("目前栈里的数据为：\n");
    for (int i = 0; i < LengthSeqStack(p); i++)
    {
        printf("%d ", GetTopSeqStack(p));
    }

    printf("\n");

    printf("请输入你要插入的数据：\n");
    scanf("%d", &data);
    PushStack(p, data);

    printf("出栈操作：\n");
    while (!IsEpSeqStack(p))
    {
        printf("出栈的数据为：%d ", PopSeqStack(p));
    }
    printf("\n");

    free(p->data);
    p->data = NULL;
    free(p);
    p = NULL;

    return 0;
}

链式栈

1.逻辑结构：线性结构
2.存储结构：链式存储
3.操作：入栈、出栈

结构体

typedef struct linkstack
{
    datatype data;          // 数据域
    struct linkstack *next; // 指针域
} linkstack_t;

链式栈的相关操作案例

头文件linkstack.h:

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_
#include <stdio.h>
#include <stdlib.h>
// 入栈和出栈只在第一个节点位置操作
typedef int datatype;
typedef struct linkstack
{
    datatype data;          // 数据域
    struct linkstack *next; // 指针域
} linkstack_t;

// 1.创建一个空的栈
void CreateEpLinkStack(linkstack_t **ptop);
// 2.入栈   data是入栈的数据
// 参数上之所以采用二级指针，因为我们要随着入栈添加新的节点作为头，top需要永远指向当前链表的头，
// 那么修改main函数中的top，我们采用地址传递
int PushLinkStack(linkstack_t **ptop, datatype data);
// 3.判断栈是否为空
int IsEpLinkStack(linkstack_t *top);
// 4.出栈
datatype PopLinkStack(linkstack_t **ptop);
// 5.清空栈
void ClearLinkStack(linkstack_t **ptop); // 用二级指针，是因为清空后需要将main函数中的top变为NULL
// 6.求栈的长度
int LengthLinkStack(linkstack_t *top); // 用一级指针，是因为我只是求长度，不需要修改main函数中top指针的指向
// 7.获取栈顶数据,不是出栈,不需要移动main函数中的top，所以用一级指针
datatype GetTopLinkStack(linkstack_t *top);
#endif

顺序栈函数linkstack.c:

#include "linkstack.h"

// 1.创建一个空的栈
void CreateEpLinkStack(linkstack_t **ptop)
{
    *ptop = NULL;
}

// 2.入栈
// data是入栈的数据
// 参数上之所以采用二级指针，因为我们要随着入栈添加新的节点作为头，top需要永远指向当前链表的头，那么修改main函数中的top，我们采用地址传递
int PushLinkStack(linkstack_t **ptop, datatype data)
{
    // 1.创建一个新节点，并初始化
    linkstack_t *pnew = (linkstack_t *)malloc(sizeof(linkstack_t));
    if (pnew == NULL)
    {
        perror("PushLinkStack函数出错\n");
        return -1;
    }
    pnew->data = data;
    pnew->next = NULL;

    // 2.将新节点插到无头单向链表中
    pnew->next = *ptop;

    // 3.移动栈针，栈针永远指向无头单向链表的第一个节点
    *ptop = pnew;

    return 0;
}

// 3.判断栈是否为空
int IsEpLinkStack(linkstack_t *top)
{
    return top == NULL;
}

// 4.出栈     *ptop-->top
datatype PopLinkStack(linkstack_t **ptop)
{
    // 1.容错判断(判空)
    if (IsEpLinkStack(*ptop))
    {
        perror("PopLinkStack函数出错\n");
        return -1;
    }

    // 2.定义pdel指向被删除节点
    linkstack_t *pdel = *ptop;

    // 3.定义一个变量temp保存出栈数据
    datatype temp = pdel->data; // datatype temp = (*ptop)->data;

    // 4.移动指针
    *ptop = pdel->next; // *ptop = (*ptop)->next;

    // 5.释放被删除节点
    free(pdel);
    pdel = NULL;
    return temp;
}

// 5.清空栈
void ClearLinkStack(linkstack_t **ptop) // 用二级指针，是因为清空后需要将main函数中的top变为NULL
{
    while (!(IsEpLinkStack(*ptop)))
    {
        PopLinkStack(ptop);
    }
}

// 6.求栈的长度
int LengthLinkStack(linkstack_t *top) // 用一级指针，是因为只是求长度，不需要修改main函数中top指针的指向
{
    int len = 0;
    while (top != NULL)
    {
        top = top->next;
        len++;
    }
    return len;
}

// 7.获取栈顶数据,不是出栈,不需要移动main函数中的top，所以用一级指针
datatype GetTopLinkStack(linkstack_t *top)
{
    if (IsEpLinkStack(top))
    {
        perror("GetTopLinkStack函数出错\n");
        return -1;
    }
    
    return top->data;
}

主函数main.c:

#include "linkstack.h"

int main(int argc, char const *argv[])
{
    linkstack_t *p = NULL;
    for (int i = 1; i <= 5; i++)
    {
        PushLinkStack(&p, i);
    }
    printf("栈的长度为：%d\n", LengthLinkStack(p));

    while (!(IsEpLinkStack(p)))
    {
        printf("%d ", PopLinkStack(&p));
    }
    printf("\n");

    ClearLinkStack(&p);

    return 0;
}

总结

顺序栈和链式栈的区别

(1)存储结构不同，顺序栈相当于数组，连续的，链式栈 链表非连续的 
(2)顺序栈的长度受限制，而链栈不会

队列

顺序队列(循环队列) 和 链式队列 

队列的定义

只允许在两端进行插入和删除操作的线性表，在队尾插入，在队头删除 插入的一端，被称为"队尾"，删除的一端被称为"队头"。

在队列操作过程中，为了提高效率，以调整指针代替队列元素的移动，并将数组作为循环队列的操作空间。

队列的特点

先进先出 FIFO  first in first out

后进后出 LILO  last

顺序队列(又称为循环队列)

1.逻辑结构: 线性结构

2.存储结构：顺序存储结构

3.操作：入列，出列

结构体

 #define N 5

typedef int datatype;

typedef struct

{

datatype data[N];

int rear;  //存数据端  rear 后面

int front; //取数据端  front 前面

}sequeue_t;//sequence 顺序  queue队列

 注意：

循环队列中，假设数组的元素个数为N，那么循环队列中存储最多的数据个数为N-1个

原因：舍去数组上的一个存储位置,用于判断队列是否为满

顺序队列的相关操作案例

头文件sequeue.h:

#ifndef _SEQUEUE_H_
#define _SEQUEUE_H_
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef int datatype;
typedef struct
{
    datatype data[N]; // 循环队列的数组
    int rear;         // 存数据端 rear 后面
    int front;        // 取数据端 front 前面
} sequeue_t;
// 1.创建一个空的队列
sequeue_t *CreateEmptySequeue();
// 2.入列 data代表入列的数据
int InSequeue(sequeue_t *p, datatype data);
// 3.判断队列是否为满
int IsFullSequeue(sequeue_t *p);
// 4.判断队列是否为空
int IsEmptySequeue(sequeue_t *p);
// 5.出列
datatype OutSequeue(sequeue_t *p);
// 6.求队列的长度
int LengthSequeue(sequeue_t *p);
// 7.清空队列函数
void ClearSequeue(sequeue_t *p);
#endif

顺序队列函数sequeue.c:

#include "sequeue.h"
// 1.创建一个空的队列
sequeue_t *CreateEmptySequeue()
{
    // 1.开辟一个结构体大小的空间
    sequeue_t *p = (sequeue_t *)malloc(sizeof(sequeue_t));
    if (p == NULL)
    {
        perror("CreateEmptySequeue函数报错\n");
        return NULL;
    }
    // 2.初始化
    p->rear = p->front = 0;
    return p;
}

// 2.入列 data代表入列的数据
int InSequeue(sequeue_t *p, datatype data)
{
    // 1.判满
    if (IsFullSequeue(p))
    {
        perror("InSequeue函数出错\n");
        return -1;
    }

    // 2.将数据入列
    p->data[p->rear] = data;
    p->rear = (p->rear + 1) % N;
    return 0;
}

// 3.判断队列是否为满
int IsFullSequeue(sequeue_t *p)
{
    return (p->rear + 1) % N == p->front;
}

// 4.判断队列是否为空
int IsEmptySequeue(sequeue_t *p)
{
    return p->rear == p->front;
}

// 5.出列
datatype OutSequeue(sequeue_t *p)
{
    // 1.判空
    if (IsEmptySequeue(p))
    {
        perror("OutSequeue函数出错\n");
        return -1;
    }

    // 2.出列
    // 取出数据
    datatype temp = p->data[p->front];
    // 移动对头
    p->front = (p->front + 1) % N;

    return temp;
}
// 6.求队列的长度
int LengthSequeue(sequeue_t *p)
{

    // // 1.方法一
    // if (p->rear >= p->front)
    // {
    //     return p->rear - p->front;
    // }
    // else
    // {
    //     return p->rear - p->front + N;
    // }

    // 2.方法二
    return (p->rear - p->front + N) % N;
}
// 7.清空队列函数
void ClearSequeue(sequeue_t *p)
{
    p->front = p->rear;
}

主函数main.c:

#include "sequeue.h"

int main(int argc, char const *argv[])
{
    sequeue_t *p = CreateEmptySequeue();
    for (int i = 0; i < 4; i++)
    {
        InSequeue(p, i);
    }
    printf("顺序队列的长度为：%d\n", LengthSequeue(p));
    OutSequeue(p);
    OutSequeue(p);
    OutSequeue(p);
    InSequeue(p, 10);
    printf("顺序队列的长度为：%d\n", LengthSequeue(p));
    while (!IsEmptySequeue(p))
    {
        printf("%d ", OutSequeue(p));
    }
    printf("\n");
    printf("清空顺序队列\n");
    ClearSequeue(p);
    free(p);
    p = NULL;
    return 0;
}

链式队列 

1.逻辑结构: 线性结构

2.存储结构：链式存储

3.操作：入列 、出列

结构体

typedef struct node

{

datatype data;//数据域

struct node *next;//指针域

}linkqueue_node_t,*linkqueue_list_t;

typedef struct//将队列头指针和尾指针封装到一个结构体里

{

linkqueue_list_t front;//相当于队列的头指针

linkqueue_list_t rear;//相当于队列的尾指针

//有了链表的头指针和尾指针，那么我们就可以操作这个链表

}linkqueue_t; 

链式队列的相关操作案例

头文件linkqueue.h:

#ifndef _LINKQUEUE_H_
#define _LINKQUEUQ_H_

#include <stdio.h>
#include <stdlib.h>
typedef int datatype;
typedef struct node
{
    datatype data;     // 数据域
    struct node *next; // 指针域
} linkqueue_node_t, *linkqueue_list_t;

// linkqueue_list_t p === linkqueue_node_t *
typedef struct // 将队列头指针和尾指针封装到一个结构体里
{
    linkqueue_list_t front; // 相当于队列的头指针
    linkqueue_list_t rear;  // 相当于队列的尾指针
    // 有了链表的头指针和尾指针，那么我们就可以操作这个链表
} linkqueue_t;
// 1.创建一个空的队列
linkqueue_t *CreateEmptyLinkQueue();
// 2.入列 data代表入列的数据
int InLinkQueue(linkqueue_t *p, datatype data);
// 3.出列
datatype OutLinkQueue(linkqueue_t *p);
// 4.判断队列是否为空
int IsEmptyLinkQueue(linkqueue_t *p);
// 5.求队列长度的函数
int LengthLinkQueue(linkqueue_t *p);
// 6.清空队列
void ClearLinkQueue(linkqueue_t *p);
#endif

链式队列函数linkqueue.c:

#include "linkqueue.h"
// 1.创建一个空的队列
linkqueue_t *CreateEmptyLinkQueue()
{
    // 1.开辟一个结构体大小的空间
    linkqueue_t *p = (linkqueue_t *)malloc(sizeof(linkqueue_t));
    if (p == NULL)
    {
        perror("CreateEmptyLinkQueue函数出错\n");
        return NULL;
    }
    // 2.初始化
    p->front = p->rear = NULL;
    return p;
}

// 2.入列 data代表入列的数据
int InLinkQueue(linkqueue_t *p, datatype data)
{
    linkqueue_list_t pnew = (linkqueue_list_t)malloc(sizeof(linkqueue_node_t));
    if (pnew == NULL)
    {
        perror("InLinkQueue函数出错\n");
        return -1;
    }
    pnew->next = NULL;
    pnew->data = data;

    if (IsEmptyLinkQueue(p)) // 队列为空的情况
    {
        p->front = p->rear = pnew;
    }
    else
    {
        p->rear->next = pnew;
        p->rear = pnew;
    }
    return 0;
}

// 3.出列
datatype OutLinkQueue(linkqueue_t *p)
{
    if (IsEmptyLinkQueue(p))
    {
        perror("OutLinkQueue函数出错\n");
        return -1;
    }
    linkqueue_list_t temp = p->front;
    datatype data = temp->data;

    p->front = p->front->next;

    return data;
}

// 4.判断队列是否为空
int IsEmptyLinkQueue(linkqueue_t *p)
{
    return p->front == NULL;
}

// 5.求队列长度的函数
int LengthLinkQueue(linkqueue_t *p)
{
    int len = 0;
    linkqueue_list_t q = p->front;
    while (q != NULL)
    {
        len++;
        q = q->next;
    }
    return len;
}

// 6.清空队列
void ClearLinkQueue(linkqueue_t *p)
{
    linkqueue_list_t q = p->front;
    while (q != NULL)
    {
        linkqueue_list_t temp = q;
        q = q->next;
        free(temp);
    }
    p->front = p->rear = NULL; // 将队列头尾指针置为空
}

主函数main.c：

#include "linkqueue.h"

int main(int argc, char const *argv[])
{
    linkqueue_t *p = CreateEmptyLinkQueue();

    InLinkQueue(p, 1);
    InLinkQueue(p, 2);
    InLinkQueue(p, 3);
    printf("链式队列的长度为：%d\n", LengthLinkQueue(p));
    printf("%d ", OutLinkQueue(p));
    printf("%d ", OutLinkQueue(p));
    printf("%d ", OutLinkQueue(p));
    printf("\n");

    printf("清空链式队列\n");
    ClearLinkQueue(p);

    free(p);
    p = NULL;

    return 0;
}
何物爱惜雨#1110
关注
  • 19
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2024年统招“专升本”考前模拟测试卷《数据结构》课程数据结构数据结构十四.rar
01-15
在2024年的统招“专升本”考前模拟测试中，《数据结构》这门课程的重要性不言而喻。这份名为“数据结构十四”的压缩包文件很可能包含了与数据结构相关的练习题或模拟试卷，帮助学生备考。 数据结构主要包括以下几个...
2024年统招“专升本”考前模拟测试卷《数据结构》课程数据结构数据结构九.rar
01-15
2. **栈与队列**：栈是后进先出（LIFO）的数据结构，常用于表达式求值、递归等；队列是先进先出（FIFO）的数据结构，常用于任务调度、缓冲区管理。 3. **树形结构**：如二叉树、平衡树（AVL树、红黑树）、堆。...
数据结构（学习）2024.8.6（顺序表）
何物爱惜雨的博客
08-06 1163
数据结构（数据，逻辑结构，存储结构和操作），算法的相关定义和知识（算法的特性，判断标准），时间复杂度，空间复杂度，顺序表（特点，命名规则，相关操作）
2024前端面试题！（附答案及解析）（2024.8月最新版）
热门推荐
这世上从不缺让人上头的新鲜感，能顾及你情绪的人实属难得。
03-27 12万+
2024前端面试题！面试宝典！总结心得！（附答案及解析）会持续更新哦！（2024.8月最新版）感谢支持，你们的鼓励是我的动力！
前端面试题-说说你了解的js数据结构?(2024.1.29)
apple_70049717的博客
01-29 1167
数组是一组有序的值的集合，可以通过索引访问。JavaScript 数组可以包含不同的数据类型，并且长度是动态的。对象是无序的键值对的集合。每个键都是字符串或符号，值可以是任何数据类型。栈是一种后进先出（LIFO）的数据结构，只允许在顶部进行插入和删除操作。常见的应用包括函数调用堆栈。想象一下你在叠盘子，你总是把新的盘子放在最上面，那么拿出盘子时，你会从最上面开始取。后面叠的盘子先被取出，这就是后进先出。只能从最上面取盘子。不能在中间或底部插入或删除盘子。这就是栈的特点，只能在顶部进行插入和删除。
2024年王道考研数据结构——栈
qq_51536841的博客
08-07 387
2024年王道考研数据结构——栈
2024年最新版：计算机数据结构考研复习资料.zip
01-25
其中，栈是一种后进先出（LIFO）的数据结构，队列则是先进先出（FIFO）的数据结构。 3. **树形结构**：树是数据结构中的一种非线性结构，如二叉树、满二叉树、完全二叉树、平衡二叉树（AVL树、红黑树）等。二叉搜索...
2024年统招“专升本”考前模拟测试卷《数据结构》课程数据结构数据结构七.rar
01-15
2. **栈与队列**：栈是后进先出（LIFO）的数据结构，典型应用有函数调用、表达式求值等；队列是先进先出（FIFO）的数据结构，常用于任务调度、缓冲区等场景。 3. **树结构**：树是一种非线性结构，包含根节点、子...
2024年统招“专升本”考前模拟测试卷《数据结构》课程数据结构数据结构六.rar
01-15
在2024年的统招“专升本”考试中，数据结构这一主题的重要性不言而喻，因为它直接影响到程序设计、算法分析以及系统性能优化的能力。考前模拟测试卷《数据结构》旨在帮助考生熟悉和掌握这一关键领域的概念和技术。 ...
单链表-数据结构
qq_31804097的博客
08-07 121
【代码】单链表、双向带头循环链表-数据结构。
数据结构初阶：栈和队列
LCL200356的博客
08-03 875
栈的结构的定义和顺序表结构定义一样，在栈中定义一个指针data用于操作数据，然后定义整型变量capacity用于表示栈的空间大小，最后定义一个整型变量top用于表示有效数据个数也就是我们的栈顶。//定义一个栈的结构//数组//栈的空间的大小int top;//有效数据个数}ST;队列的结点结构就是单链表结点结构，队列结构phead指向头结点和ptail指向尾结点，还有一个size用同统计结点个数。//链式结构表示队列}QNode;//队列结构int size;//计数器。
算法回忆录（2）
m0_73399576的博客
08-05 1263
算法回忆录（2）
【数据结构-前缀哈希】力扣525. 连续数组
最新发布
sjsjs11的博客
08-07 100
将nums中的0全部替换成-1，然后定义一个哈希表group，键用来储存sum，值用来储存对应的前缀和的下标。当前计算前缀和sum的时候，如果前面有相同的前缀和，说明中间这个子段和为0，也就说明0和1的数量相等，所以这个时候。给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。来求这个子段的长度。
[C++进阶&数据结构]二叉搜索树
2301_80017277的博客
08-07 863
对于二叉树的结点，我们类似于list的结点定义一样，使用一个struct类。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 304
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
从零开始学数据结构系列之第四章《迪杰斯特拉算法了解》
铁匠匠匠的博客
08-04 1103
1、先选定一个根结点，并选定一个数组，先确定未遍历前的初始距离，把距离最短的邻接结点选定为中间结点，并标记访问过，开始往下遍历，挨个访问那个中间结点的邻接结点。计算出根结点到中间结点+中间结点到新邻接结点的距离，作为新距离，对比新距离和旧距离，如果新距离大，则把新距离替换掉旧距离，否则不变。算法的基本思想是：从源点出发，每次选择离源点最近的一个顶点前进，然后以该顶点为中心进行扩展，最终得到源点到其余所有点的最短路径。2、一轮访问结束后，从未标记的结点中选定距离最短的，把它作为中间结点，继续往下访问。
数据结构 | 考研代码题之顺序表 | 1 查找L中值为e的数据元素若找到则返回其下标，若找不到则返回-1
猫天意的博客
08-04 217
假设有一个顺序表 L，其存储的所有数据元素均为不重复的正数，查找L中值为e的数据元素，若找到则返回其下标，若找不到则返回-1。
数据结构图书管理系统
2305_78057683的博客
08-07 167
数据结构图书管理系统
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值