《数据结构》C语言版 栈的基本操作实现

最新推荐文章于 2024-04-05 16:38:09 发布
最新推荐文章于 2024-04-05 16:38:09 发布
阅读量1w 收藏 385
点赞数 58
分类专栏： C语言 数据结构 文章标签： 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41511151/article/details/108029684
版权

严蔚敏数据结构C语言实现栈的基本操作

源码如下：

#include<stdio.h>
#include<stdlib.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define OVERFLOW -1
#define OK 1
#define ERROR 0
typedef int Status;
typedef int SElemType;

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

Status InitStack(SqStack* S)//构造一个空栈
{
    S->base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if (!S->base) exit(OVERFLOW);
    S->top = S->base;
    S->stacksize = STACK_INIT_SIZE;
    return OK;
}

Status Push(SqStack* S, SElemType e)//插入元素e为新的栈顶元素
{
    if (S->top - S->base >= S->stacksize)
    {
        S->base = (SElemType*)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(SElemType));
        if (!S->base) exit(OVERFLOW);
        S->top = S->base + S->stacksize;
        S->stacksize += STACKINCREMENT;
    }
    *S->top++ = e;
    return OK;
}

Status Pop(SqStack* S, SElemType* e)//用e返回栈顶元素并删除栈顶元素
{
    if (S->top == S->base)
        return ERROR;
    *e = *--S->top;
    return OK;
}

Status GetTop(SqStack S, SElemType* e)//返回栈顶元素
{
    if (S.top == S.base)
        return ERROR;
    *e = *(--S.top);
    return OK;
}

Status StackEmpty(SqStack S)//若栈为空，返回OK，否则返回ERROR
{
    if (S.top == S.base)
        return OK;
    else
        return ERROR;
}

int StackLength(SqStack S)//返回栈的长度
{
    return (S.top - S.base);
}

Status PrintElem(SElemType e)//visit指针函数的调用
{
    printf("%d\t", e);
    return OK;
}

Status StackTraverse(SqStack S, Status(*visit)(SElemType))//栈的遍历
{
    SElemType* p;
    p = S.base;
    while (p != S.top)
    {
        if (!visit(*p))
            return ERROR;
        p++;
    }
    return OK;
}

Status ClearStack(SqStack* S)//置为空栈
{
    S->top = S->base;
    return OK;
}

Status DestroyStack(SqStack* S)//销毁栈
{
    free(S->base);
    S->base = NULL;
    S->top = NULL;
    S->stacksize = 0;
    return OK;
}

int main()
{
    SqStack S;
    SElemType e;
    int n, i;
    InitStack(&S);
    printf("请输入需要入栈的数据个数:\n");
    scanf_s("%d", &n);
    printf("请输入需要入栈的%d个数据,用空格隔开:\n",n);
    for (i = 0; i < n; i++)
    {
        scanf_s("%d", &e);
        Push(&S, e);
    }
    printf("\n");
    printf("栈的遍历\n");
    StackTraverse(S, PrintElem);
    printf("\n栈的长度为：\n");
    printf("%d", StackLength(S));
    printf("\n返回栈首元素：\n");
    GetTop(S, &e);
    printf("%d", e);
    printf("\n元素出栈后\n");
    while (!StackEmpty(S))
    {
        Pop(&S, &e);
        printf("%d\t", e);
    }
    printf("\n");
    printf("\n\t\t\tBy Cherish599");
    printf("\n");
    return 0;
}

运行截图：

在这里插入图片描述

线性栈（参考大话数据结构）

源码如下：

#include<stdio.h>
#define MAXSIZE 100

typedef int SELemType;  // SELemType类型根据实际情况而定，这里假设为int
typedef struct
{
    SELemType data[MAXSIZE];
    int top;
}SeqStack;

// 栈初始化
void Init_SeqStack(SeqStack* s)
{
    
    s->top = -1;
}

// 判栈为空
int Empty_SeqStack(SeqStack* s)
{
    if (s->top == -1)
        return 1;
    else
        return 0;
}

// 入栈
void Push_Stack(SeqStack *s, SELemType e)
{
    if (s->top == MAXSIZE - 1)
        printf("Stack is full!\n");
    else
    {
        s->top++;
        s->data[s->top] = e;
    }

}

// 出栈
void Pop_SeqStack(SeqStack* s, SELemType* e)
{
    if (s->top == -1)
        printf("栈为空!\n");
    else
    {
        *e = s->data[s->top];
        s->top--;
    }
}

// 取栈顶元素
void Top_SeqStack(SeqStack* s, SELemType* e)
{
    if (s->top == -1)
        printf("栈为空!\n");
    else
    {
        *e = s->data[s->top];
        printf("出栈成功！\n");
    }
}
// 输出
void Output_SeqStack(SeqStack* s)
{
    SeqStack* w;
    int i;
    printf("栈中的元素有：");
    for (i = s->top; i >= 0; i--)
        printf("%d ", s->data[i]);
    printf("\n");

}

void Menu()
{
    puts("****************");
    puts("1.初始化");
    puts("2.判断栈为空");
    puts("3.入栈");
    puts("4.出栈");
    puts("5.取栈顶元素");
    puts("0.程序结束");
    puts("****************");

}

// 主函数
int main()
{
    SeqStack S;
    int choice = -1, i,n;
    SELemType e;
    Menu();
    while (choice == -1)
    {
        printf("\nYour choice is:");
        scanf_s("%d", &i);
        switch (i)
        {
        case 1:
            Init_SeqStack(&S);
            printf("初始化完成！\n");
            break;
        case 2:
            if(Empty_SeqStack(&S) == 1)
                printf("栈为空!\n");
            else
                printf("栈不为空！\n");
            break;
        case 3:
            printf("请输入入栈的数量：");
            scanf_s("%d", &n);
            printf("请输入需要入栈的数据,用空格隔开：");
            for (int j = 0; j < n; j++)
            {
                scanf_s("%d", &e);
                Push_Stack(&S, e);
            }
            Output_SeqStack(&S);
            break;;
        case 4:
            Pop_SeqStack(&S, &e);
            Output_SeqStack(&S);
            break;
        case 5:
            Top_SeqStack(&S, &e);
            printf("栈顶元素为：%d\n", e);
            Output_SeqStack(&S);
            break;
        case 0:
            choice = 0;
            break;
        default:printf("选择有误，请重新选择 \n");
        }
    }
    puts("\n");
    puts("\t\t\t\t  By Cherish599");
    return 0;
}

运行截图：

在这里插入图片描述

两栈共享空间：

如果有两个类型相同的栈，我们为它们分别开辟了数组空间。极有可能是一个栈已经满了，再入栈就溢出了，而另一个栈却还有很多存储空间。这又何必呢？我们完全可以用一个数组来存储两个栈，只不过需要一些小的技巧。
我们的做法如下，数组有两个端点，两个栈有两个栈底。让一个栈的栈底为数组的始端，即数组下标为0的位置。让另一个栈的栈底为数组的末端，即数组下标为n-1的位置。这样如果两个栈增加元素，就是两端点向中间延伸。

在这里插入图片描述

从这里可以分析出来，栈 1 为空时，就是top1等于-1；而当top2等于n时，即栈2为空；当top1 + 1 == top2 时为栈满
1. 两栈共享空间的结构代码
typedef struct {
    SElemType data[MAXSIZE];
    int top1;                    //栈1的栈顶指针(top1==-1,表示栈1为空)
    int top2;                    //栈2的栈顶指针(top2==MAXSIZE,表示栈2为空)
}SqDoubleStack;
2.入栈操作(stackNumber判断是栈1还是栈2)
Status push(SqDoubleStack *S, SElemType e, int stackNumber) {
    if (S->top1 + 1 == S->top2) {                    //栈满
        return ERROR;    
    }
    if (stackNumber == 1) {                    //表示栈1有元素进栈
        top1 ++;
        S->data[top1] = e;
    } else if (stackNumber == 2) {                    //表示栈2有元素进栈
        top2--;
        S->data[top2] = e;
    }
    return OK;
}
3.出栈操作
Status Pop(SqDoubleStack *S, SElemType *e, int stackNumber) {
    if (stackNumber == 1) {                //说明是删除栈1元素
          if (S->top1 == -1) {                    //栈1空
            return ERROR;
        }
        *e = S->data[S->top1]
        S->top1--;
    } else if (stackNumber == 2) {              //说明是删除栈2元素
        if (S->top2 == MAXSIZE) {        //栈2空
            return ERROR;            
        }
        *e = S->data[S->top2];
        S->top2++;
    }
    return OK;  
}

栈的链式存储结构：（参考大话数据结构）

链栈指向图：

在这里插入图片描述

源码如下：


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

#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int EleType;

typedef struct StackNode {
	EleType data;//结点数据域
	struct StackNode* next;//结点指针域
}StackNode, * LinkStackPoi;

//链栈的数据结构
typedef struct LinkStack {
	LinkStackPoi top;//栈顶结点
	int count;//元素个数
}LinkStack;

//初始化
Status InitLinkStack(LinkStack* stack)
{
	if (!stack)
	{
		return	ERROR;
	}
	stack->top = NULL;
	stack->count = 0;
	return OK;
}

//清空数据，释放结点内存，实际上就是pop所有数据
Status ClearLinkStack(LinkStack* stack)
{
	if (!stack || !stack->count)
	{
		return	ERROR;
	}
	while (stack->count)
	{
		StackNode* node = stack->top;
		stack->top = node->next;
		free(node);
		stack->count--;
	}
	return OK;
}

//判断链栈是否为空
Status EmptyLinkStack(LinkStack* stack) {
	if (!stack)
	{
		return ERROR;
	}
	return stack->count == 0 ? 1 : 0;
}

//获取元素个数
int GetLengthLinkStack(LinkStack* stack)
{
	if (!stack)
	{
		return	-1;
	}
	return stack->count;
}

// 获取栈顶元素
Status GetTop(LinkStack* stack, StackNode* stackNode)
{
	if (!stack)
	{
		return	ERROR;
	}
	*stackNode = *(stack->top);//将栈顶元素的副本内容，修改不会影响到栈顶元素。
	return OK;
}


/*
弹栈
栈顶指针指向要弹出元素前置结点，然后释放弹出元素内存空间，然后count-1
*/
Status pop(LinkStack* stack, EleType* e)
{
	if (!stack && stack->count)
	{
		return	ERROR;
	}
	StackNode* node = stack->top;
	*e = node->data;
	stack->top = node->next;//栈顶指针指向新的栈顶元素
	free(node);//释放元素空间
	stack->count--;
	return OK;
}


/*
压栈
先将压入元素放入到链表表中，然后再将栈顶指针指向压入的元素，然后count+1.
*/
Status push(LinkStack* stack, EleType e)
{
	if (!stack)
	{
		return ERROR;
	}
	StackNode* node = (StackNode*)malloc(sizeof(StackNode));
	node->next = stack->top;//将元素加入链表中
	node->data = e;
	stack->top = node;//栈顶元素指向压入元素
	stack->count++;
	return OK;
}

// 输出栈的元素
void PrintfLinkStack(LinkStack* stack)
{
	if (!stack && stack->count)
	{
		return;
	}
	StackNode* node = stack->top;
	while (node)
	{
		printf("%d,", node->data);
		node = node->next;
	}
	puts("");
	return;
}

int main(int argc, char* argv[])
{
	LinkStack stack;
	StackNode snode;
	InitLinkStack(&stack);//初始化
	push(&stack, 1);
	push(&stack, 2);
	push(&stack, 3);
	push(&stack, 4);
	push(&stack, 5);
	puts("链栈元素：");
	PrintfLinkStack(&stack);
	printf("链栈元素个数：%d\n", GetLengthLinkStack(&stack));
	EleType e1, e2;
	pop(&stack, &e1);
	printf("弹出第一个元素：%d\n", e1);
	pop(&stack, &e2);
	printf("弹出第二个元素：%d\n", e2);
	puts("链栈元素：");
	PrintfLinkStack(&stack);
	printf("链栈元素个数：%d\n", GetLengthLinkStack(&stack));

	printf("栈顶元素为: %d\n",GetTop(&stack, &snode));
	printf("\n");
	printf("\t\t\t\t By Cherish599");
	puts("\n");
	return 0;

}

运行截图：

在这里插入图片描述

Q183cm
关注
  • 58
    点赞
  • 踩
  • 385
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
《数据结构》（C语言）链式栈的基本操作
10-27
《数据结构》（C语言）链式栈的基本操作，可以用C语言实现出栈、进栈、取栈顶元素、判栈空、置栈空等链式栈的基本操作。
C语言 数据结构中栈的实现代码
09-01
数据结构中的栈是一种非常基础且重要的抽象数据类型，它的特点是具有后进先出（LIFO，Last In First Out）的特性。栈的操作主要包括入栈（Push）和出栈（Pop）。在C语言中，我们可以使用两种方式来实现栈：静态栈...
C语言数据结构--栈 基本操作代码合集
最新发布
m0_70744482的博客
04-05 474
三段代码分别是栈的顺序存储，带头结点的链式存储，不带头结点的链式存储。都包括着初始化、判空、进栈、建立栈表、出栈，读取栈顶元素、遍历操作，方便大家调试。
[简述]数据结构-栈(c语言实现)
second60的博客
04-22 735
[简述]数据结构-栈(c语言实现)second60 201804221. 栈的定义栈是一种只能在一端进行插入或删除操作的线性表。 表中只允许插入的一端叫栈顶，另一端叫栈底。栈的特点是：后进先出。 2. 栈的抽象数类型定义ADT Stack{数据对象：D={ai | i&lt;=i &lt;= n,n&gt;=0,ai ElemType类型}数据关系：R={&lt;ai, ai+1&gt; | ai...
C语言数据结构，栈的基本操作。
weixin_47303191的博客
01-29 154
设计思路：顺序栈：初始化一个栈，让栈顶指针为-1；这样可让当判断栈是否为空时，可判断栈顶指针是否为-1就可以了，相反若判断沾满，可判定栈顶指针和最大容量-1是否相等。在进行栈的出栈，进栈，取栈顶元素的时，都要进行栈顶指针位置的判断，即判断其是否为空或满。 #include<stdio.h> #define ok 1 #define error 0 #define max 1000 typedef int data; typedef struct{ data hyb[max]; dat
数据结构C语言实现栈
Just Insist on doing
07-15 514
头文件 #ifndef STACKHEAD_H_INCLUDED #define STACKHEAD_H_INCLUDED #include #include #include #define STACK_INIT_SIZE 10 #define STACK_INCR_SIZE 3 typedef struct Sqstack {     int* Sba
数据结构之C语言栈的实现
weixin_46599926的博客
06-13 579
一、栈模型 栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈的顶(top)。栈有时又称为LIFO（后进先出）表。 栈的应用 Expression evaluation Backtracking Memory Management 二、栈的实现 1. 定义结构体 typedef struct { double *values; int top; int maxTop; } Stack; 2. 栈的创建 这里我们初始化top为-1， 则存第一个元素的时候 top 为0，相当于
C语言数据结构之栈简单操作
01-01
C语言数据结构之栈简单操作 实验： 编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能： （1）初始化顺序栈 （2）插入元素 （3）删除栈顶元素 （4）取栈顶元素 （5）遍历顺序栈 ...
数据结构C语言实现栈和队列的基本操作
12-12
本项目重点探讨了两种基本数据结构——栈（Stack）和队列（Queue），并使用C语言进行了实现。C语言是一种底层编程语言，适合进行这种底层数据结构的构建，因为它提供了对内存管理的直接控制。 栈是一种后进先出...
C语言对栈的实现基本操作
09-01
总之，C语言中实现栈的基本操作涉及到对数据结构的理解和动态内存管理的运用。通过理解这些操作，我们可以更好地理解和实现各种算法，解决实际问题。在编写这类代码时，应特别注意内存泄漏和异常处理，确保程序的...
数据结构-链栈（C语言实现）
04-14
数据结构-链栈（C语言实现）
c语言数据结构栈的基本操作
06-03
自己做的课程设计，可以实现站的各项基本的操作传上来共享一下
数据结构的栈的基本操作C语言实现
06-12
本代码对如何构建一个空栈，然后再向栈中插入元素，删除元素，并将栈的元素输出
数据结构之 栈（C语言实现）
热门推荐
men_wen的博客
03-14 1万+
数据结构之 栈（C语言实现）1.栈的模型栈（stack）是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈的顶（top）。对栈的基本操作有push（进栈）和pop（出栈），前者相当于插入，后者则是删除最后插入的元素。最后插入的元素可以通过使用top例程在执行pop之前进行考察。对空栈进行的pop或top一般被认为是栈ADT的错误。另一方面，当运行push时空间用尽是一个实现错误，但不
数据结构C语言之栈的简单实现
gyzsky的专栏
02-28 358
#include "stdafx.h" #include #include #define STACKSIZE 10 typedef struct{ int *base; int *top; int stacksize; }Stack; int _tmain(int argc, _TCHAR* argv[]) { //初始化栈 void initStack
数据结构——C语言实现栈
我爱吃香锅的博客
09-23 933
C语言实现栈 1.栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 2.栈的实现： 栈的实现一般可以使用数组或者链表实现，相对...
数据结构之栈-c语言实现
无心的博客
01-31 857
文章来源：http://blog.seclibs.com/数据结构之栈-c语言实现/ 在上一篇文章中说过，栈在实现上分为顺序栈和链式栈两种。 顺序栈： 用数组实现的栈 链式栈： 用链表实现的栈 因为栈就是一种“功能受限”的顺序表，所以在实现的时候，在之前数组和链表的基础上进行修改即可达到效果。 顺序栈 在实现顺序栈的时候，为了更好的表示栈顶元素top，我将之前数组中的使用个数used替换为top，...
数据结构栈的基本操作实现(C语言实现)
qq_42169456的博客
10-08 530
栈的基本操作的实现 栈:是一种受限的链表只允许在同一端插入(入栈:Push)和删除(出栈:Pop)，所以栈遵循先进后出的原则 #include <stdio.h> #include <stdlib.h> typedef int ElementType; typedef struct Node { ElementType element; struct Node *next; } Node, *Stack; //****************定义基本操作****
数据结构C语言实现-栈
weixin_46935703的博客
05-11 226
仅利用C语言实现栈，及相关操作
《数据结构》C语言版-基本操作与栈的实现
本资源主要围绕《数据结构》（C语言版）中的基本操作实现，特别是栈的类型定义和结构，同时提到了数据结构在计算机科学中的重要性以及相关教材和参考文献。 在计算机科学中，数据结构是至关重要的一个领域，它研究...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值