栈和队列 C语言实现

最新推荐文章于 2024-02-11 22:34:53 发布
最新推荐文章于 2024-02-11 22:34:53 发布
阅读量9.4k 收藏 75
点赞数 21
分类专栏： Data structure & Algorithm 文章标签： 循环队列 链队 队列c实现 循环队列空间扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wtfmonking/article/details/16989159
版权
1、栈的概念

栈又称堆栈，它是一种运算受限的线性表，其限制是仅允许在表的一端进行插入和删除运算。

2、栈的顺序存储结构和操作实现

栈的顺序存储结构示意图：


下面通过一个实例展示栈的顺序存储结构的操作实现，其中包含了6种操作：

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;  //定义元素类型
struct StackSq         //定义栈结构类型
{
    ElemType* stack;   //存栈元素的数组指针
    int top;           //存栈顶元素的下标位置
    int MaxSize;       //存stack数组长度
};

//栈满需要重新分配更大空间 的情况
void againMalloc(struct StackSq* S)
{
    ElemType *p = realloc(S->stack, 2*S->MaxSize*sizeof(ElemType));//此处重新分配的空间为原来的2倍
    if (!p)  //重新分配失败
    {
        printf("存储空间用完！\n");
        exit(1);
    }
    S->stack = p;             //使list指向新栈空间
    S->MaxSize = 2 * S->MaxSize;
    printf("存储空间已扩大为当前的2倍！\n");//输出提示已扩充空间
}

//1、初始化栈S为空
void InitStack(struct StackSq* S, int ms)
{
    if (ms < 0)
    {
        printf("ms的值非法！\n");
        exit(1);
    }
    S->MaxSize = ms;
    S->stack = malloc(ms*sizeof(ElemType));
    if (!S->stack)
    {
        printf("动态存储分配失败！\n");
        exit(1);
    }
    S->top = -1;   //值为-1，表示栈空
}

//2、新元素进栈，即把它插入到栈顶
void Push(struct StackSq* S, ElemType x)
{
    if (S->top == S->MaxSize - 1)
        againMalloc(S);
    S->top++;
    S->stack[S->top] = x;
}

//3、删除栈顶元素并返回值
ElemType Pop(struct StackSq* S)
{
    if (S->top == -1)
    {
        printf("栈空，无元素出栈！\n");
        exit(1);
    }
    S->top--;
    return S->stack[S->top + 1];
}

//4、读取栈顶元素的值（并不改变栈）
ElemType Peek(struct StackSq* S)
{
    if (S->top == -1)
    {
        printf("栈空，无任何元素！\n");
        exit(1);
    }
    return S->stack[S->top];
}

//5、判断S是否为空。若是空返回1，否则返回0
int EmptyStack(struct StackSq* S)
{
    if (S->top == -1)
        return 1;
    else
        return 0;
}

//6、清除栈S中的所有元素，释放动态存储空间
void ClearStack(struct StackSq* S)
{
    if (S->stack)
    {
        free(S->stack);   //释放存储空间
        S->stack = 0;
        S->top == -1;
        S->MaxSize = 0;
    }
}

//主函数
void main()
{void againMalloc(struct List *L)
{
    ElemType *p = realloc(L->list, 2*L->MaxSize*sizeof(ElemType));//此处重新分配的空间为原来的2倍
    if (!p)  //重新分配失败
    {
        printf("存储空间用完！\n");
        exit(1);
    }
    L->list = p;             //使list指向新线性表空间
    L->MaxSize = 2 * L->MaxSize;
    printf("存储空间已扩大为当前的2倍！\n");//输出提示已扩充空间
}
    struct StackSq s;
    int a[8] = {3, 8, 5, 17, 9, 30, 15, 22};
    int i;
    InitStack(&s, 5);
    for (i = 0; i < 8; i++)
        Push(&s, a[i]);
    printf("%d ", Pop(&s));
    printf("%d \n", Pop(&s));
    Push(&s, 68);
    printf("%d ", Peek(&s));
    printf("%d \n", Pop(&s));
    while (!EmptyStack(&s))
        printf("%d ", Pop(&s));
    printf("\n");
    ClearStack(&s);
}

运行结果：


3、栈的链接存储结构和操作实现

栈的链接存储结构与线性表的链接存储结构相同。

栈的链接存储结构及操作过程示意图：


下面通过一个实例展示栈的链接存储结构的操作，其中包括6种操作

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

typedef int ElemType;  //定义元素类型
struct sNode           //定义链栈结点类型
{
    ElemType data;
    struct sNode* next;
};

//1、初始化链栈为空
void InitStack(struct sNode** HS)
{
    *HS = NULL;   //HS表示栈顶指针
}

//2、向链栈中插入一个元素
void Push(struct sNode** HS, ElemType x)
{
    struct sNode *newp;
    newp = malloc(sizeof(struct sNode));
    if (newp == NULL)
    {
        printf("内存动态空间用完，退出运行！\n");
        exit(1);
    }
    newp->data = x;
    newp->next = *HS;
    *HS = newp;
}

//3、从链栈中删除栈顶元素并返回它
ElemType Pop(struct sNode** HS)
{
    struct sNode* p;
    ElemType temp;
    if (*HS == NULL)
    {
        printf("栈空无法删除！\n");
        exit(1);
    }
    p = *HS;
    *HS = p->next;
    temp = p->data;
    free(p);
    return temp;
}

//4、读取栈顶元素
ElemType Peek(struct sNode** HS)
{
    if (*HS == NULL)
    {
        printf("栈空，无栈顶结点！\n");
        exit(1);
    }
    return (*HS)->data;
}

//5、检查链栈是否为空
int EmptyStack(struct sNode** HS)
{
    if (*HS == NULL)
        return 1;
    else
        return 0;
}

//6、清除链栈为空
void ClearStack(struct sNode** HS)
{
    struct sNode *cp, *np;
    cp = *HS;
    while (cp != NULL)
    {
        np = cp->next;
        free(cp);
        cp = np;
    }
    *HS = NULL;
}

//主函数
void main()
{
    struct sNode *a;
    int x = 0;
    int m[8] = {3, 8, 5, 17, 9, 30, 15, 22};
    printf("当前序列：3,8,5,17,9,30,15,22\n");
    InitStack(&a);
    while (x != 8)
    {
        Push(&a, m[x]);
        x++;
    }
    printf("逆序列为：");
    while (!EmptyStack(&a))
        printf("%d,", Pop(&a));
    printf("\n");
    ClearStack(&a);
}

运行结果：


4、队列概念

队列也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入（队尾），在表的另一端进行删除（队首）。

5、队列的顺序存储结构和操作实现（循环列队）

如上图，当队列处于图（d）的状态时不可再插入元素，不然就越界了，但实际队列空间并未占满，为了解决这个问题，就有了循环队列，如下图：

图片展示的很详细，为了区分队空和队满，我们采取少用一个元素空间，约定以“对头指针在队尾指针的下一位置（指环状的下一位置）上”作为队列满状态的标志。

                                  空队列时：Q.front = Q.rear = 0;

                                   一般情况时：入队一个元素，尾指针后移一次，出队一个元素，头指针后移一次。

                                   队列满时：( Q.rear + 1 ) % MaxSize == Q.front （如图中的情况为：（5+1）% 6 == 0）

注意，当情况如下时：


插入a1元素时，Q.rear后移一个位置，但不是直接加1，比如上图 : 5+1=6，但实际位置应为0，所以必须写成：

Q.rear = ( Q.rear + 1) % MaxSize ;

删除元素时的情况同理。

注意：关于内存不足时扩大内存的情况，若Q.rear = Q.MaxSize - 1 时，即 Q.rear 为 5 时，直接扩大内存即可，但当Q.rear ！= Q.MaxSize - 1 时，如下图：（Q.rear,2）


此时，原来位置为0、1位置的元素现在变成了位置为6、7的元素了，而且队尾指针由原来的2变成了8，所以内存扩大后应该进行操作（后面有详细讲解）：

        for (i = 0; i < Q->rear; i++)
            Q->queue[i + Q->MaxSize] = Q->queue[i];
        Q->rear += Q->MaxSize;


具体情况见下面的程序代码。

下面通过一个实例展示队列顺序存储的操作，包含6种操作

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
struct QueueSq
{
    ElemType *queue;   //指向存储队列的数组空间
    int front, rear;   //队首指针、队尾指针
    int MaxSize;       //queue数组长度
};

//扩展存储空间函数
void againMalloc(struct QueueSq* Q)
{
    ElemType *p;
    p = realloc(Q->queue, 2*Q->MaxSize*sizeof(ElemType));
    if (!p)
    {
        printf("存储空间用完！\n");
        exit(1);
    }
    Q->queue = p;     //使queue指向新的队列空间
    if (Q->rear != Q->MaxSize - 1)
    {
        int i;
        for (i = 0; i < Q->rear; i++)                                
            Q->queue[i + Q->MaxSize] = Q->queue[i];   //原队列的尾部内容后移MaxSize个位置
        Q->rear += Q->MaxSize;                                    //队尾指针后移MaxSize个位置
    }
    Q->MaxSize = 2*Q->MaxSize;                                //队列空间修改为原来的2倍
    printf("存储空间已为当前2倍！\n");
}
//1、初始化队列
void InitQueue(struct QueueSq* Q, int ms)
{
    if (ms <= 0)
    {
        printf("ms值非法！\n");
        exit(1);
    }
    Q->MaxSize = ms;
    Q->queue = malloc(ms*sizeof(ElemType));
    if (!Q->queue)
    {
        printf("内存空间用完！\n");
        exit(1);
    }
    Q->front = Q->rear = 0;    //置队列为空
}

//2、向队列插入元素
void EnQueue(struct QueueSq* Q, ElemType x)
{
    if ((Q->rear + 1) % Q->MaxSize == Q->front)  //队空间满
        againMalloc(Q);
    Q->queue[Q->rear] = x;                       //插入值
    Q->rear = (Q->rear + 1) % Q->MaxSize;        //队尾指针后移一个位置
}

//3、从队列中删除元素并返回
ElemType OutQueue(struct QueueSq* Q)
{
    ElemType temp;
    if (Q->front == Q->rear)
    {
        printf("队列已空，无法删除！\n");
        exit(1);
    }
    temp = Q->queue[Q->front];                  //保存队首元素值
    Q->front = (Q->front + 1) % Q->MaxSize;     //使队首后移一个位置
    return temp;
}

//4、读取队首元素，不改变队列状态
ElemType PeekQueue(struct QueueSq* Q)
{
    if (Q->front == Q->rear)
    {
        printf("队列已空，无法读取！\n");
        exit(1);
    }
    return Q->queue[Q->front];
}

//5、检查一个队列是否为空，若是则返回1，否则返回0
int EmptyQueue(struct QueueSq* Q)
{
    if (Q->front == Q->rear)
        return 1;
    else
        return 0;
}

//6、清除一个队列为空，释放动态存储空间
void ClearQueue(struct QueueSq* Q)
{
    if (Q->queue != NULL)
    {
        free(Q->queue);
        Q->queue = 0;
        Q->front = Q->rear = 0;
        Q->MaxSize = 0;
    }
}

//主函数
void main()
{
    struct QueueSq q;
    int a[8] = {3,8,5,17,9,30,15,22};
    int i;
    InitQueue(&q, 5);
    for (i = 0; i < 8; i++)
        EnQueue(&q, a[i]);
    printf("%d ", OutQueue(&q));
    printf("%d \n", OutQueue(&q));
    EnQueue(&q, 68);
    printf("%d ", PeekQueue(&q));
    printf("%d \n", OutQueue(&q));
    while (!EmptyQueue(&q))
        printf("%d ", OutQueue(&q));
    printf("\n");
    ClearQueue(&q);
}

运行结果：


为验证和详解上面提到的内存扩大问题，我们把上面的主函数换为如下：

void main()
{
    struct QueueSq q;
    struct QueueSq* p = &q;
    int a[5] = {3,8,5,17,9};
    int i;
    InitQueue(&q, 6);
    for (i = 0; i < 5; i++)
        EnQueue(&q, a[i]);
    printf("%d ", OutQueue(&q));
    printf("%d ", OutQueue(&q));
    printf("%d \n", OutQueue(&q));
    EnQueue(&q, 67);
    printf("插入了67！\n");
    EnQueue(&q, 68);
    printf("插入了68！\n");
    EnQueue(&q, 69);
    printf("插入了69！\n");
    EnQueue(&q, 100);
    printf("插入了100！\n");
    printf("%d ", PeekQueue(&q));          //显示队头元素
    printf("\n");
    for (i = 0; i < 12; i++)
        printf("%d ,", p->queue[i]);     //显示所有元素
    printf("\n");
    while (!EmptyQueue(&q))
        printf("%d ", OutQueue(&q));
    printf("\n");
    ClearQueue(&q);
}

运行结果：

分析：先是依次入队 3,8,5,17,9 五个元素，然后出队3,8,5三个元素，再然后入队67,68，69三个元素，此时状态如下图的左图，

注意：出队的元素虽然不在队里，但在内存里仍存在，如图中的暗绿色的元素。

下面当要将100入队时，内存空间不够，扩大为原来的2倍，此时队中的尾端位置将发生变化如下右图，（暗绿色元素并不在队里）

此时的队头位置元素仍为 17，一次输出下标从0到11位置的内存内容：如上面的运行结果所示，68,69,5仍存在，下标6，7，8三个位置为别是68,69,100，后面的空间无值。

将队的所有元素出队，结果即为上图的运行结果中的：17,9,67,68,69,100。

至此循环顺序队列的相关内容已经非常清晰了。


6、队列的链接存储结构和操作实现

链队的示意图如下：

下面通过实例展示链队的6种操作

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
struct sNode             //结点类型
{
    ElemType data;       //值域
    struct sNode* next;  //链接指针域
};
struct QueueLk           //队列链接存储结构类型
{
    struct sNode* front; //队首指针
    struct sNode* rear;  //队尾指针
};

//1、初始化链队
void InitQueue(struct QueueLk* HQ)
{
    HQ->front = HQ->rear = NULL;
}

//2、向链队中插入元素
void EnQueue(struct QueueLk* HQ, ElemType x)
{
    struct sNode* newp;
    newp = malloc(sizeof(struct sNode));
    if (newp == NULL)
    {
        printf("内存动态空间用完，退出运行！\n");
        exit(1);
    }
    newp->data = x;
    newp->next = NULL;
    if (HQ->front == NULL)  //若链队为空，则新节点既是队首结点又是队尾结点
        HQ->front = HQ->rear = newp;
    else       //若链队非空，则依次修改队尾结点的指针域和队尾指针，使之都指向新的队尾结点
        HQ->rear = HQ->rear->next = newp;
}

//3、从链队中删除元素并返回
ElemType OutQueue(struct QueueLk* HQ)
{
    struct sNode* p;
    ElemType temp;
    if (HQ->front == NULL)
    {
        printf("队列为空，无法删除！\n");
        exit(1);
    }
    temp = HQ->front->data;
    p = HQ->front;
    HQ->front = p->next; //使队首指针指向下一个结点
    if (HQ->front == NULL) //若删除后队空，则使队尾指针也变为空
        HQ->rear = NULL;
    free(p);
    return temp;
}

//4、读取队首元素，不改变队列状态
ElemType PeekQueue(struct QueueLk* HQ)
{
    if (HQ->front == NULL)
    {
        printf("队列已空，无法读取！\n");
        exit(1);
    }
    return HQ->front->data;
}

//5、检查一个链队是否为空，若是则返回1，否则返回0
int EmptyQueue(struct QueueLk* HQ)
{
    if (HQ->front == NULL)
        return 1;
    else
        return 0;
}

//6、清除链队为空，释放动态存储空间
void ClearQueue(struct QueueLk* HQ)
{
   struct sNode* p = HQ->front;
   while (p != NULL)  //依次删除队列中的每一个结点，循环结束后队首指针已变为空
   {
        HQ->front = HQ->front->next;
        free(p);
        p = HQ->front;
   }
   HQ->rear = NULL;  //置队尾指针为空
}

//主函数
void main()
{
    struct QueueLk q;
    int a[8] = {3,8,5,17,9,30,15,22};
    int i;
    InitQueue(&q);
    for (i = 0; i < 8; i++)
        EnQueue(&q, a[i]);
    printf("%d ", OutQueue(&q));
    printf("%d \n", OutQueue(&q));
    EnQueue(&q, 68);
    printf("%d ", PeekQueue(&q));
    printf("%d \n", OutQueue(&q));
    while (!EmptyQueue(&q))
        printf("%d ", OutQueue(&q));
    printf("\n");
    ClearQueue(&q);
}

运行结果同循环队列相同，只是链队无需考虑内存空间的大小。


wtfmonking
关注
  • 21
    点赞
  • 踩
  • 75
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构栈和队列C语言实现.pdf
09-30
数据结构栈和队列C语言实现.pdf
C语言栈和队列的实现
k666499436的博客
05-28 4128
详细讲解栈与队列的定义和特性，用C语言分别实现顺序栈、链栈、顺序(循环)队列、链队列，已经顺序存储与链式存储的区别
栈和队列实现
weixin_63178060的博客
10-01 437
栈是一种特殊的线性表，其只允许在固定的一端进行插入删除。进行数据插入和删除的一端称为栈顶，另一端称为栈底。
C语言实现栈与队列
最新发布
2301_79432671的博客
02-11 761
不直接定义一个数组，而采用realloc、malloc来动态管理顺序表大小，使栈的大小不再受限。再定义一个top栈顶指针来方便后续的增删操作。//将int类型重定义叫做MyDataType//一个MyDataType类型的指针，可以进行动态内存开辟//栈的最大容量int top;//用于栈顶指针}ST;队列是只允许在一端插入元素，另一端删除元素的线性表，特点是先进先出。Queue这个结构体中还包含两个QNode结点结构体。包含队列头尾结点，能够帮助从队尾插入和从队头删除。
队列和栈(C语言)
zhouhaoNB_的博客
02-22 227
现在，假设队列和栈都是空的。的：把队列看成横向的一个通道，则 push k 是将 k 放到队列的最右边，而 pop 则是从队列的最左边取出一个数。的：把栈也看成横向的一个通道，则 push k 是将 k 放到栈的最右边，而 pop 也是从栈的最右边取出一个数。队列 1 2 -------> 1 2 5 ------> 2 5。栈 1 2 -------> 1 2 5 ------> 1 2。则队列中的元素为Queue[]={1，2，3，4，5，6}例如队列中的元素Queue[]={1，2，3，4，5}，
栈和队列的定义和实现（详细）
z_h666的博客
08-13 1079
栈和队列的定义和实现 栈和队列的定义和特点 栈和队列是限定插入和删除只能在表的“端点”进行的线性表 是线性表的特殊情况 栈 栈的示意图 栈的应用 数值转换、表达式求值 括号匹配、八皇后问题 行编译程序、函数调用 迷宫问题、递归调用的实现 栈的定义 栈是限定仅在表尾进行插入和删除操作的线性表 栈的相关概念 1.定义：限定只能在表的一端进行插入和删除运算的线性表(只能在栈顶操作) 2.逻辑结构：与线性表相同,仍为一对一关系。 3.存储结构：用顺序栈戟链栈存储均可,但以顺
C语言——栈与队列的实现
weixin_40203143的博客
12-28 2916
栈与队列都是受限的线性表，均可以通过顺序表（数组）和链表两种方式得到实现。只不过栈是FILO，队列是FIFO，即栈和队列在出和入的方式上有所不同。而通过数组和链表实现的区别，即为数组与链表本身的区别：数组的存储空间是连续的，不可动态扩展；链表的存储空间是不连续的，可以动态扩展。下面具体来说。 一、栈的实现： 栈有栈底和栈顶，栈底是固定的，栈顶指向栈最顶上的第一个数据；数据的入栈和出栈只能在栈顶...
C语言栈和队列代码实现
08-08
包含内容：栈、队列、循环队列的数组实现方式和链表实现方式
C语言用栈和队列实现的回文检测功能示例
01-20
本文实例讲述了C语言用栈和队列实现的回文功能。分享给大家供大家参考，具体如下： #include #include<malloc>//内存分配头文件 #include<math.h>//在math.h中已定义OVERFLOW的值为3 #define SIZE 100 #...
栈和队列（必会基础代码，万字解析）
weixin_69884785的博客
08-20 427
栈和队列（基础必会代码，万字解析）
栈的实现原理与分析
chen
05-14 752
栈 github地址 栈也是一种线性结构 相比数组，栈对应的操作是数组的子集 只能从一端添加元素，也只能从一端取出元素，这一端称为栈顶 栈是一种后进先出的数据结构 LIST IN FIRST OUT(LIFO) 在计算机的世界里，栈拥有着不可思议的作用 应用 无处不在的Undo操作（撤销） 程序调用使用的系统栈 括号匹配-编译器 时间复杂度分析 ArrayStack void push(E) 入栈 O(1) 均摊 E pop() 出栈 O(1) 均摊 E peek() 查看栈顶元素
C语言实现栈和队列
Sun_student的博客
01-08 3006
一、栈（原理：FILO||LIFO）        实现思想：利用静态顺序表实现栈                      1.定义结构体，包含值和数组还有栈顶成员变量记录栈内元素个数（栈主要就是对栈顶元素的操作）                      2.初始化、销毁（比较简单看代码理解）                      3.增操作：先判断栈是否已满，再在栈顶进行添加；（...
C语言---栈和队列
qq_62743629的博客
05-01 3184
严格来说,栈和队列都属于线性表 "一对一" 栈:"先进后出" 队列: "先进先出" 栈 栈只能从一端存取,另一端是封闭的 在栈中,不论是存还是取,都必须遵循"先进后出"的原则 ==>栈是一种只能从表的一端存取数据,且遵循"先进后出"原则的线性存储结构 进栈和出栈 进栈:将数据存储到栈里面去 出栈:将数据从栈中间取出来 栈的实现方法 栈:有点"特殊"的线性存储结构 顺序表==>顺序栈 (顺序存储结构) 链表==>链栈 (链式存储结构)
数据结构----栈+队列完整C代码(代码易懂)
weixin_45637300的博客
07-27 2111
前言 本篇博客依旧适合那些学过数据结构中栈及队列知识的人，不适合那些刚开始接触这个相关知识的读者，当然的话，如果你是未入门这门知识，你可以先收藏起来，等你学完这个相关知识后，可以看一下这篇博客。好了，话不多说，直接整代码吧。 栈的链式存储结构 //栈的链式存储结构 #include<stdio.h> #include<malloc.h> #include<stdlib.h> #include<time.h> #include<windows.h>
数据结构之栈与队列（完整代码）
起个名字真难的博客
07-24 1820
栈与队列顺序栈链栈（带头结点）顺序队列循环队列栈的应用匹配括号中缀表达式转后缀表达式递归（斐波那契数列） 顺序栈 //栈，先进后出 #include<iostream> #include<algorithm> using namespace std; typedef int ElemType; #define MaxSize 10 typedef struct{ ElemType data[MaxSize]; int top; }SqStack; void
【C】用队列实现栈（力扣225）和用栈实现队列（力扣232）
You don't have the guts to be what you wanna be.
04-09 72
队列和栈的相互实现
栈和队列相关操作及代码
TinyHorse的博客
09-21 883
栈和队列
数据结构栈和队列完整代码复习
狂小伍的博客
11-29 206
栈和队列的完整代码实现
 数据结构栈和队列c语言
10-19
栈和队列是两种常见的数据结构，它们都可以用来存储一系列的数据，并且具有不同的...在C语言中，栈和队列可以用数组或链表来实现。引用和分别介绍了链队列和顺序队列的存储结构，而引用则介绍了循环队列的实现方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值