栈的实现

最新推荐文章于 2023-07-29 17:59:13 发布
最新推荐文章于 2023-07-29 17:59:13 发布
阅读量1k 收藏 4
点赞数
分类专栏： 数据结构 文章标签： 栈 数据结构 双向栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zitong_ccnu/article/details/10834677
版权

栈的实现：栈的链式实现、栈的数组实现、O(1)实现FindMin()、双向栈的实现

需要定义几个头文件：

fatal.h//实现错误处理

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

#define FatalError(str) fprintf(stderr, "%s\n", str),exit(1)

stack.h//栈函数声明（用于栈的链式实现、栈的数组实现、O(1)实现FindMin()） 
#ifndef STACK_H
#define STACK_H

typedef int ElementType;
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;

int IsEmpty(Stack S);//栈是否为空
Stack CreateStack(void);//新建空栈
void ClearStack(Stack S);//清空栈
void DisposeStack(Stack *S);//销毁栈
void Push(ElementType X, Stack S);//X入栈
ElementType Pop(Stack S);//出栈并返回出栈元素
ElementType Peek(Stack S);//读取栈顶元素
ElementType FindMin(Stack S);//查找栈中最小元素，此功能只适用于第三种实现

#endif
stackmain.c//测试栈的实现（前三个都可以用此文件进行测试） 
#include <stdio.h>
#include "stack.h"

#define M 10

int main(void)
{
	Stack S;
	int i;

	S = CreateStack();
	for(i = 10; i > 0; i -= 2)
		Push(i, S);
	for(i = 1; i <= M; i += 2)
		Push(i, S);
	while(!IsEmpty(S))
		printf("%d : %d\n", Pop(S), FindMin(S));
	printf("\n");
	DisposeStack(&S);
	return 0;
}

1. 栈的链式实现

#include "fatal.h"
#include "stack.h"
#include <assert.h>

struct Node
{
	ElementType Data;//数据域
	struct Node *Next;//指针域
};

int IsEmpty(Stack S)
{
	return S->Next == NULL;
}

Stack CreateStack(void)
{
	Stack S;
	S = (PtrToNode)malloc(sizeof(struct Node));
	S->Next = NULL;
	return S;
}

void ClearStack(Stack S)
{
	PtrToNode TmpCell, P;

	P = S->Next;
	S->Next = NULL;
	while(P)
	{
		TmpCell = P->Next;
		free(P);
		P = TmpCell;
	}
}

void DisposeStack(Stack *S)
{
	PtrToNode P, TmpCell;

	P = *S;
	*S = NULL;
	while(P)
	{
		TmpCell = P->Next;
		free(P);
		P = TmpCell;
	}
}

void Push(ElementType X, Stack S)
{
	PtrToNode TmpCell;

	TmpCell = (Stack)malloc(sizeof(struct Node));
	if(TmpCell == NULL)
		FatalError("Out of space");
	TmpCell->Data = X;
	TmpCell->Next = S->Next;
	S->Next = TmpCell;
}

ElementType Pop(Stack S)
{
	PtrToNode TmpCell;
	ElementType X;

	assert(0 == IsEmpty(S));

	TmpCell = S->Next;
	S->Next = TmpCell->Next;
	X = TmpCell->Data;
	free(TmpCell);
	return X;
}

ElementType Peek(Stack S)
{
	assert(0 == IsEmpty(S));
	return S->Next->Data;
}

ElementType FindMin(Stack S)
{
	return -1;
}
2. 栈的数组实现 
#include "fatal.h"
#include "stack.h"
#include <assert.h>

#define EmptyToStack (-1)
#define INITIALSIZE 11 

struct Node
{
	ElementType *Array;//数组
	int Capacity;//最大容量
	int TopOfStack;//栈顶指针
};

int IsEmpty(Stack S)
{
	return S->TopOfStack == EmptyToStack;
}

Stack CreateStack(void)
{
	Stack S;
	S = (Stack)malloc(sizeof(struct Node));
	if(S == NULL)
		FatalError("Out of space");
	S->Array = (ElementType*)malloc(sizeof(ElementType) * INITIALSIZE);
	if(S->Array == NULL)
		FatalError("Out of space");
	S->Capacity = INITIALSIZE;
	S->TopOfStack = EmptyToStack;
	return S;
}

void ClearStack(Stack S)
{
	S->TopOfStack = EmptyToStack;
}

void DisposeStack(Stack *S)
{
	if(*S != NULL)
	{
		free((*S)->Array);
		free(*S);
		*S = NULL;
	}
}

void Push(ElementType X, Stack S)
{
	if(S->TopOfStack == S->Capacity - 1)
	{
		S->Array = (ElementType *)realloc(S->Array, sizeof(ElementType) * (S->Capacity * 2));
		if(S->Array == NULL)
			FatalError("Out of space");
		S->Capacity = S->Capacity * 2;
	}

	S->Array[++S->TopOfStack] = X;
}

ElementType Pop(Stack S)
{
	assert(0 == IsEmpty(S));
	return S->Array[S->TopOfStack--];
}

ElementType Peek(Stack S)
{
	assert(0 == IsEmpty(S));
	return S->Array[S->TopOfStack];
}

ElementType FindMin(Stack S)
{
	return -1;
}
3. O(1)实现FindMin()查找栈中的最小元素 
#include "fatal.h"
#include "stack.h"
#include <assert.h>

#define EmptyToStack (-1)
#define SIZE 11

struct Node
{
	ElementType *Array;//数据栈
	ElementType *Min;//存储最小元素的栈
	int Capacity; //数据容量
	int MinCapacity;//存放最小元素的栈
	int TopOfStack;//数据栈栈顶指针
	int TopOfMin;//最小元素栈栈顶指针
};

int IsEmpty(Stack S)
{
	return S->TopOfStack == EmptyToStack;
}

Stack CreateStack(void)
{
	Stack S;

	S = (Stack)malloc(sizeof(struct Node));
	if(S == NULL)
		FatalError("Out of space");
	S->Array = (ElementType *)malloc(sizeof(ElementType) * SIZE);
	if(S->Array == NULL)
		FatalError("Out of space");
	S->Min = (ElementType *)malloc(sizeof(ElementType) * SIZE);
	if(S->Min == NULL)
		FatalError("Out of space");
	S->Capacity = SIZE;
	S->MinCapacity = SIZE;
	S->TopOfStack = EmptyToStack;
	S->TopOfMin = EmptyToStack;

	return S;
}

void ClearStack(Stack S)
{
	S->TopOfMin = EmptyToStack;
	S->TopOfStack = EmptyToStack;
}

void DisposeStack(Stack *S)
{
	if(*S != NULL)
	{
		free((*S)->Array);
		free((*S)->Min);
		free(*S);
		*S = NULL;
	}
}

void Push(ElementType X, Stack S)
{
	if(S->TopOfStack == S->Capacity - 1)
	{
		S->Array = (ElementType *)realloc(S->Array, sizeof(ElementType) * (S->Capacity * 2));
		if(S->Array == NULL)
			FatalError("Out of space");
		S->Capacity *= 2;
	}
	S->Array[++S->TopOfStack] = X;
	if(S->TopOfMin == EmptyToStack)
		S->Min[++S->TopOfMin] = X;
	else if(X <= S->Min[S->TopOfMin])
	{
		if(S->TopOfMin == S->MinCapacity - 1)
		{
			S->Min = (ElementType *)realloc(S->Min, sizeof(ElementType) * (S->MinCapacity * 2));
			if(S->Min == NULL)
				FatalError("Out of space");
			S->MinCapacity *= 2;
		}
		S->Min[++S->TopOfMin] = X;
	}
}

ElementType Pop(Stack S)
{
	ElementType X;
	assert(0 == IsEmpty(S));
	X = S->Array[S->TopOfStack--];
	if(X == S->Min[S->TopOfMin])
		S->TopOfMin--;
	return X;
}

ElementType Peek(Stack S)
{
	assert(0 == IsEmpty(S));
	return S->Array[S->TopOfStack];
}

ElementType FindMin(Stack S)
{
	assert(0 == IsEmpty(S));
	return S->Min[S->TopOfMin];
}
4. 数组实现双向队列（跟前三个有所不同这里重新定义了stack.h并改名为DoubleStack.h）

DoubleStack.h

#ifndef STACK_H
#define STACK_H

typedef int ElementType;
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;

int IsEmpty(Stack S, int val);//0表示左边入栈，非零表示右边入栈
int IsFull(Stack S);
Stack CreateStack(void);
void ClearStack(Stack S);
void DisposeStack(Stack *S);
void Push(ElementType X, Stack S, int val);
ElementType Pop(Stack S, int val);
ElementType Peek(Stack S, int val);

#endif

DoubleStack.c//双向栈的具体实现

#include "fatal.h"
#include "stack.h"
#include <assert.h>

#define EmptyToStack (-1)
#define MAXCAPACITY (20)
#define INF -1

struct Node
{
	ElementType *Array;
	int TopOfFront;
	int TopOfBack;
	int Capacity;
};

int IsEmpty(Stack S, int val)
{
	if(val)
		return S->TopOfBack == S->Capacity;
	else
		return S->TopOfFront == EmptyToStack;
}

int IsFull(Stack S)
{
	return S->TopOfBack == S->TopOfFront + 1;
}

Stack CreateStack(void)
{
	Stack S;

	S = (Stack)malloc(sizeof(struct Node));
	if(S == NULL)
		FatalError("Out of space");
	S->Array = (ElementType *)malloc(sizeof(ElementType) * MAXCAPACITY);
	if(S->Array == NULL)
		FatalError("Out of space");
	S->Capacity = MAXCAPACITY;
	S->TopOfFront = EmptyToStack;
	S->TopOfBack = S->Capacity;

	return S;
}

void ClearStack(Stack S)
{
	S->TopOfBack = S->Capacity;
	S->TopOfFront = EmptyToStack;
}

void DisposeStack(Stack *S)
{
	if(*S != NULL)
	{
		free((*S)->Array);
		free(*S);
		*S = NULL;
	}
}

void Push(ElementType X, Stack S, int val)
{
	if(!IsFull(S))
	{
		if(val)
			S->Array[--S->TopOfBack] = X;
		else
			S->Array[++S->TopOfFront] = X;
	}
	//else
	//	FatalError("Stack is full");
}

ElementType Pop(Stack S, int val)
{
	ElementType X = INF;
	if(!IsEmpty(S, val))
	{
		if(val)
			X = S->Array[S->TopOfBack++];
		else
			X = S->Array[S->TopOfFront--];
	}
	return X;
}

ElementType Peek(Stack S, int val)
{
	ElementType X = INF;

	if(!IsEmpty(S, val))
	{
		if(val)
			X = S->Array[S->TopOfBack];
		else
			X = S->Array[S->TopOfFront];
	}

	return X;
}

DoubleStackMain.c//用于测试双向栈

#include <stdio.h>
#include "stack.h"
#define M 10
int main(void)
{
	Stack S;
	int i;

	S = CreateStack();
	for(i = 20; i > 0; i --)
		Push(i, S, 0);
	for(i = 1; i <= M; i += 2)
		Push(i, S, 1);
	printf("Left: ");
	while(!IsEmpty(S, 0))
		printf("%d ", Pop(S, 0));
	printf("\nRight: ");
	while(!IsEmpty(S, 1))
		printf("%d ", Pop(S, 1));
	putchar('\n');
	DisposeStack(&S);
	system("Pause");
	return 0;
}

Brent-CCNU
关注
专栏目录
栈实现表达式运算
03-28
C语言实现栈实现表达式运算的应用，很好用，有需要的来下载。
【数据结构】栈的实现
qq_59702185的博客
08-18 1612
栈是一种特殊的线性表，只允许在表尾进行插入和删除元素的操作。进行数据的插入和删除操作的一端称为栈顶，另一侧称为栈底。栈中的数据元素严格遵循后进先出LIFO（Last in First Out）的原则。压栈：栈的插入操作称为进栈/压栈/入栈，插入的数据在栈顶出栈：栈的删除操作称为出栈，删除的数据也在栈顶在顺序表里面我们就讲过，顺序表分为静态顺序表和动态顺序表。静态顺表不够灵活，容量或多或少，不能由我们控制。所以我们要用支持动态的栈。...
【数据结构】栈（Stack）的实现 -- 详解
最新发布
Elena's Blog
07-29 1586
一种特殊的线性表，其只允许在表尾进行插入和删除元素操作。。栈中的数据元素遵守后进先出 LIFO（Last In First Out）的原则。：栈的插入操作叫做进栈 / 压栈 / 入栈，。：栈的删除操作叫做出栈。。
【数据结构】栈的实现详解（c语言）
m0_72532428的博客
03-24 1074
数据结构栈的分享
栈实现队列
01-09
栈实现队列 栈实现队列是一种使用栈数据结构来实现队列操作的技术。队列是一种First-In-First-Out（FIFO）的数据结构，栈是一种Last-In-First-Out（LIFO）的数据结构。通过使用两个栈，可以实现队列的入队和出队...
顺序栈实现
05-27
C++ 是一种通用的编程语言，以其强大的模板系统而闻名，使得在C++中实现各种数据结构变得非常灵活。在这个场景中，我们将探讨如何使用C++模板来创建一个顺序栈。 首先，我们需要定义一个顺序栈类，它通常包含两个...
C++ 自定义栈实现迷宫求解
08-30
"C++ 自定义栈实现迷宫求解" C++ 自定义栈实现迷宫求解是一种常见的算法问题，通过自定义栈来实现迷宫的求解。下面我们将详细介绍该问题的知识点。 一、什么是栈？ 栈是一种数据结构，它具有先进后出的特性(FILO)...
用栈实现进制转换
10-04
该资源利用栈的知识实现了进制转换，包含栈的建立，清空，压栈，出栈等基本操作，以及辗转相除法求余数
栈实现迷宫
11-03
供C++初学者参考，代码没什么难度，放网上也可以帮帮人，对初学者有帮助的
用栈实现汉诺塔问题
03-25
任意输入N个盘，在三个柱子上实现汉诺塔问题的非递归求解，用栈进行
C++使用一个栈实现另一个栈的排序算法示例
08-30
C++使用一个栈实现另一个栈的排序算法示例 C++使用一个栈实现另一个栈的排序算法示例是指利用C++语言实现栈排序算法，使用一个临时栈来辅助排序的技术。这种算法可以将栈中的元素从小到大排序，且只使用一个临时栈...
java栈实现计算器中缀表达式
10-23
java数字栈和符号栈模拟计算器(中缀表达式) “计算中缀表达式”可以称得上是一个特别经典的关于栈的算法题，几乎在所有数据结构教材中都会涉及，而且很多公司面试或者笔试的时候都会把这道题作为一个考察点。可以说...
用栈实现计算器
03-18
在本文件中，通过使用C++编程语言，实现了一个基于栈的计算器。该计算器采用两个栈，一个用于存储数字，另一个用于存储运算符。具体的实现细节如下： 知识点1：栈（Stack）的基本概念 栈是一种先进后出（FILO, ...
栈的实现(C语言版)
学代码的咸鱼的博客
04-23 2890
大家好！这篇我们继续讲解数据结构里的栈。 文章目录栈的概念及结构栈的实现栈的结构栈的初始化 栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 我们知道了栈的概念，现在就开始去实现它。 栈的实现 栈一般分为数组栈和链式栈： 相对而言数组的结构实现更优一些。因为数组在尾上插入数
栈的两种实现方式
weixin_45646463的博客
12-24 1965
一、数组实现栈 首先定义一个数组来储存数据，定义一个变量来存储数组中储存元素得个数，编写一个构造方法来构造一个长度为十得数组。 编写向栈中添加的元素得方法，首先需要查看栈是是否可以存储添加的元素，若数组已满的话则扩充数组容量。 编写查看和取出栈顶元素的方法。 代码如下： package MyStack; import java.util.Arrays; public class MySta...
数据结构---栈的实现
shijinghe的博客
03-27 3239
一、栈 学习栈之前我们需要认识栈究竟是什么东西。 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶 图解↓： 图中数据都是从栈顶进入，当图中1，2，3，4都进入，先出栈的只能是4，但也可以边进边出，举例：所以不一定出栈顺序就是4 3 2 1..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值