堆栈与单调栈

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量315 收藏 8
点赞数 4
文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80481426/article/details/139095273
版权

进栈和出栈的示意图

当元素进栈时，栈顶指针指向第一个为空的元素地址。

当元素出栈时，栈顶指针向下移动一个存储单元

//栈的类型定义
typedef  int  ElemType ;
typedef struct stack
{   
      ElemType  *bottom;   //栈底指针 
      ElemType  *top;      //栈顶指针 
      int   stacksize ;       //当前栈的容量 
}Stack ;

/*栈的初始化
假设初始时给栈分配存储空间大小为STACK_SIZE，栈的容量也赋值为STACK_SIZE。
栈初始化算法的主要过程：
1）为栈分配存储空间（也就是给栈底指针分配空间，这是因为栈底是固定不动的）；
2）让栈顶指针指向栈底（表示栈是空的）。*/
Status Init_Stack( Stack  &S  )
{
	S.bottom=(ElemType *)malloc(STACK_SIZE *sizeof(ElemType));
	if ( !S.bottom ) //判断分配空间是否成功，如果失败则返回错误
	      return  ERROR;
	S.top = S.bottom ;    //初始化时让栈顶指针指向栈底
	S. stacksize = STACK_SIZE; //初始化时
	return OK ;
}//Init_Stack

/*进栈（也称压栈、入栈）
元素进栈算法的主要过程：
1）首先判断栈的容量是否已经达到最大，如果达到，则追加存储空间，并重新定位栈顶指针的位置（其实就是指向实际的栈顶），然后更新栈的容量；
2）把入栈元素存入栈顶；
3）栈顶指针指向新栈顶。*/
Status Push(Stack &S , ElemType  e)
{
	//如果栈满，则使用realloc追加存储空间
	if( S.top-S.bottom >= S. stacksize-1 )      
    {
		S.bottom=(ElemType *)realloc( S.bottom, (S.stacksize+STACK_SIZE) * sizeof(ElemType));  
        if( !S.bottom )//如果重新分配存储空间失败，则返回错误     
            return  ERROR; 
		S.top = S.bottom + S.stacksize;//重新定位栈顶 
		S.stacksize += STACKINCREMENT;//更新栈的容量 
	}
	*S.top = e;//把元素存入栈顶  
	S.top++; //栈顶指针加1（即向上移动一个存储单元），e成为新的栈顶   
	return OK;
}//Push

/*出栈（也称弹栈）
元素出栈算法的主要过程：
1）判断栈是否是控制，如果是则返回出栈失败；
2）栈顶指针下移一个存储单元；
3）把栈顶指针指向位置的元素存入到目标变量中*/
Status Pop( Stack  &S, ElemType  &e )      
{   
	if( S.top == S.bottom ) //栈空，返回失败  
		return ERROR ;  
	S.top--;//栈顶下移
	e = *S.top;//用e缓存栈顶元素
	return  OK; 
}// Pop 

/*取栈顶元素
取栈顶元素的主要步骤：
1）判断栈是否为空，为空则返回失败
2）取栈顶元素并存储到相应的变量中，需要注意的是栈顶元素实际存储在栈顶指针的下一个存储空间中。*/
Status GetTopElement( Stack S, ElemType  &e )      
{   
	if ( S.top == S.bottom ) //如果栈为空，则返回失败
		return ERROR ;       
	e = *(S. top – 1) ;      //用e缓存栈顶元素
	return  OK ; 
}//GetTopElement

/*把栈置为空栈
把栈置为空栈的主要步骤：
1）把栈顶指针指向栈底即可。*/
Status ClearStack( Stack &S )
{   
	S.top = S.bottom; 
	return  OK ; 
}// ClearStack

/*销毁栈
销毁栈的主要步骤：
1）释放栈底指针（因为栈的存储空间是通过给栈底指针分配空间得到的）
2）把栈底指针和栈顶指针均赋值为NULL
3）把栈的容量赋值为0*/
Status DestroyStack( Stack &S )      
{   
	free( S.bottom );
	S.top =  NULL;
	S.bottom  = NULL;
	S. stacksize = 0;
	return  OK ; 
}// DestroyStack

链栈与链栈的应用

链栈的基本操作

注：

1.链栈不需要设置头结点，因为链栈的插入和删除元素都在只能在栈顶操作。

2.栈分外部结构和内部结构，外部结构是指栈顶指针top；内部结构是指栈的结点环环相扣，链栈的内部结构类似于单链表，但next的指向方向不同，链栈是由栈顶指向栈底，即从后往前指，而单链表是从前往后指，注意区别！

3. 在链栈出栈操作中，需注意要存放出栈元素，须先在主函数定义一个dataType类型的变量elem（注意是“ 变量 ”而不是 “ 指针变量 ”），然后调用出栈函数时将elem的地址传给形参，即pop_out（&s，&elem），通过变量地址传入函数间接访问的方式，才能成功的用elem存取出栈元素的值。

//链栈的实现及功能
#include<stdio.h>
#include<stdlib.h>

typedef int datatype;

//栈的内部结构，即栈的结点
typedef struct node
{
	datatype data;
	struct node *next;
}stacknode;

//栈的外部结构
typedef struct stack
{
	stacknode *top;//栈顶指针
	int length;//栈的节点数（元素个数）
}linkstack;

//[1]栈的初始化,初始化外部结构即可
void initalize(linkstack **s)
{
	(*s)->top=NULL;//栈顶指针置空，注意*s要加括号
	(*s)->length=0;//栈顶元素初始值为0，节点数也为0
}

//[2]入栈，链栈与顺序栈不同，链栈入栈不需要判栈满
void push(linkstack **s,datatype value)
{
	//对内部结构的操作（先）
	stacknode *p;
	p=(stacknode*)malloc(sizeof(stacknode));
	p->data=value;
	p->next=(*s)->top;//这里注意：链栈中next的指向与链表中next的指向不同，链栈由栈顶指向栈底，即由后往前指。而链表是由前往后指
	//对外部结构的操作（后）
	(*s)->top=p;
	(*s)->length++;
	
}

//[3]出栈，需判断栈是否为空
void popout(linkstack **s,datatype *value)
{
	stacknode *p;
	if((*s)->length==0){
		printf("此链栈为空");
		return;
	}
	p=(*s)->top;
	*value=(*s)->top->data;//此步骤是用于存放出栈的元素，注意事项见注3
	(*s)->top=p->next;
	(*s)->length--;
	printf("pop element is %d\n",*value);
}

//[4]得到栈顶元素
datatype gettop(linkstack *s)
{
	if(s->length==0)
		printf("linkstack is empty\n");
	else
		return(s->top->data);
}

//[5]栈的遍历及输出
void traverse(linkstack *s)
{
	stacknode *p;
	int i;
	if(s->length==0){
		printf("linkstack is empty\n");
		return;
	}
	p=s->top;
	printf("the elements in the stack are:");
	for(i=0;i<s->length;i++){
		printf("%d->",p->data);//从栈顶指向栈底部
		p=p->next;
	}
	printf("stack base\n");
}

int main()
{
	linkstack *s;
	datatype value;
	initalize(&s);
	push(&s,10);
	push(&s,10);
	push(&s,10);
	push(&s,10);
	popout(&s,&value);
	traverse(s);
	

	return 0;
}

栈的应用

1：进制转换

算法:假如N为输入的数，n为要转换为的进制，若要将十进制231转换为8进制数，过程如下;

N                        N/n                      N%n

231                   28                         7

28                      3                           4

3                        0                           3

则输出为347，可以看出，首先得到的应该是7，然后才是4，最后是3，但是要逆序显示，自然就类似压栈出栈的数据结构了（数组也可以实现，但是没有体现其本质）.

所以，只需要初始化栈后，将N%n不断的压入栈底，需要注意的是如果要转换为16进制，则需要对大于9的数字作字符处理。

这里提一下realloc函数

1.realloc函数会将原有空间的数据拷贝到新的空间

2.realloc函数会释放原有空间的内存

3.底层使用malloc函数实现malloc函数

申请新空间，并且需要手动移动数据，释放原有空间

//利用栈实现进制转换
#include<stdio.h>
#include<malloc.h>
#include<String.h>
#define STACKSIZE 100
#define STACKINCREMENT 10
typedef int Status;
typedef int Etype;
typedef struct stack
{   
	Etype  *bottom;   //栈底指针 
	Etype  *top;      //栈顶指针 
	int    stacksize; //当前栈的容量 
}Stack; 

Status InitStack( Stack &S );//初始化
Status Push( Stack &S , Etype e );//压栈
Status Pop( Stack  &S, Etype  &e );//弹栈
void BaseConversion( unsigned n, unsigned base );

int main()
{
	unsigned n, base;
	printf( "请输入一个十进制整数： " );
	scanf( "%ud", &n );//无符号类型的整形，打印时用%ud 
	printf( "你想将他转为几进制： " );
	scanf( "%ud", &base );
	printf( "结果： " );
	BaseConversion( n, base );
}

//栈的初始化 
Status InitStack( Stack &S )
{
	S.bottom=(Etype *)malloc(STACKSIZE *sizeof(Etype));
	if ( !S.bottom ) //判断分配空间是否成功，如果失败则返回错误
	{
		return  0;
	}
	S.top = S.bottom ;    //初始化时让栈顶指针指向栈底
	S.stacksize = STACKSIZE; //初始化时
	return 1 ;
}

//压栈（进栈、入栈） 
Status Push( Stack &S , Etype e )
{
	//如果栈满，则使用realloc追加存储空间
	if( S.top - S.bottom >= S.stacksize-1 )      
	{
		S.bottom=(Etype *)realloc( S.bottom, (S.stacksize+STACKSIZE) * sizeof(Etype) );  
		if( !S.bottom )//如果重新分配存储空间失败，则返回错误     
		{
			return  0; 
		}
		S.top = S.bottom + S.stacksize;//重新定位栈顶 
		S.stacksize += STACKINCREMENT;//更新栈的容量 
	}
	*S.top = e;//把元素存入栈顶  
	S.top++; //栈顶指针加1（即向上移动一个存储单元），e成为新的栈顶   
	return 1;
}//Push

Status Pop( Stack  &S, Etype  &e )      
{   
	if( S.top == S.bottom ) //栈空，返回失败  
	{
		return 0; 
	}	
	S.top--;   //栈顶下移
	e = *S.top;//用e缓存栈顶元素
	return 1; 
}// Pop 

void BaseConversion( unsigned n, unsigned base ) 
{
	Stack S;
	int k, e;
	InitStack( S );
	while( n > 0 )
	{
		k = n % base;
		Push( S, k );
		n = n / base;
	}
	while( S.top != S.bottom )
	{
		Pop( S, e );
		char format[3]={ '%' };
		if( base == 16 ) 
		{
			format[1] = 'x';
		}
		else
		{
			format[1] = 'u';
		}
		printf( format, e );
	}
	free( S.bottom );
}

2：判断括号是否匹配

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
#define MaxSize 100

typedef struct {
	char data[MaxSize];
	int top;
}SqStack;

//初始化栈
void InitStack(SqStack *S) {
	S->top = -1;
}
//判栈空
bool IsEmpty(SqStack S) {
	if (S.top == -1) {
		return true;
	}
	else {
		return false;
	}
}
//入栈
void Push(SqStack *S, char x) {
	if (S->top == MaxSize-1) {
		printf("栈已满");
		return;
	}
	S->top += 1;
	S->data[S->top] = x;
}
//栈顶元素出栈，用x返回
void Pop(SqStack *S, char *x) {
	if (S->top == -1) {
		printf("栈已满");
		return;
	}
	*x = S->data[S->top];
	S->top -= 1;   //S->top=S->top+1;
}
//匹配算法
bool bracketCheck(char str[], int length) {
	SqStack S;
	InitStack(&S);//初始化
	for (int i = 0; i < length; i++) {
		if (str[i] == '(' || str[i] == '[' || str[i] == '{') {
			Push(&S, str[i]);//扫描到左括号就进栈
		}
		else {
			if (IsEmpty(S)) { //扫描到右括号，栈空
				return false;//匹配失败
			}
			char topElem;//保存弹出的栈顶元素
			Pop(&S, &topElem);//栈顶元素出栈
			if (str[i] == ')' && topElem != '(') {
				return false;
			}
			if (str[i] == '}' && topElem != '{') {
				return false;
			}
			if (str[i] == ']' && topElem != '[') {
				return false;
			}
		}
	}
	return IsEmpty(S);
}
int main() {
	char c[MaxSize];
	printf("请输入需要判断的括号:");
	scanf("%s", c);
	int len = strlen(c);
	printf("当前输入括号的个数为:%d", len);
	printf("现在开始判断...");
	if (bracketCheck(c, len)) {
		printf("匹配成功!");
	}
	else {
		printf("匹配失败!");
	}
	return 0;
}

3：栈判断回文字符串

2301_80481426
关注
堆，单调队列，栈
weixin_45568353的博客
02-22 273
队列： 什么是队列？就是一个先进先出的数组，和我们日常生活中的排队很像。当我们向队列插入一个新数的时候，它插在最后，当我们取出一个数的时候，要从头取 两种导入库函数的方法 from queue import Queue que = Queue() que.put((sr, sc)) from collections import deque 栈： 什么是栈？就是一个后进先出的数组 堆： ...
大顶堆、并查集、单调栈（算法题里面这几个类型的还搞不明白）
weixin_37779325的博客
03-09 173
目录堆并查集单调栈 大顶堆、并查集、单调栈这几个类型的题目目前还搞不明白，需要反复钻研，现在做一个总结记录。（短期内集中攻坚） 堆 并查集 单调栈
单调栈、单调队列、优先队列(堆)
日常记录，挨打要立正！
11-05 241
单调栈、单调队列、优先队列——题单
【Algorithm】堆栈、队列、单调栈、单调队列
CodeEcho
02-25 576
【Algorithm】堆栈、队列、单调栈、单调队列https://ac.nowcoder.com/acm/problem/collection/2319 一、栈和排序 Problem Solution 要让字典序最大很明显就要让更大的那个数先出栈。 用 max [ i ] 表示第 i 项到第 n 项的最大值。 1. 如果栈顶元素大于第 i 项到第 n 项的最大值，那么这个元素出栈输出会使得字典序最大； 2. 如果栈顶元素小于第 i 项到第 n...
浅谈对顶栈，单调栈，对顶堆
qq_51467306的博客
09-03 1325
单调栈 定义：从栈顶到栈底保持一个单调递增或者单调递减的顺序的栈。（本质上还是一个栈） 实际作用：用于找到序列中某一个元素左边第一个比它大（或者小 的元素的位置和 右边第一个比他它小(或者大) 的元素的位置。 效率：由于序列中每个元素最多进出栈一次，所以时间复杂度是O(n). 大致图形： 以序列 1 4 5 2 7为例 那么我们应该如何维护单调栈呢？竟然已经知道了它的内部逻辑，我们不妨按照以下的步骤去维护这个栈。（假设以单调递增栈为例），对于一个无序序列，我们从头开始遍历。如果栈为空或者当前元素小于
数据结构与算法----复习Part 9 （堆栈与单调栈）
半熟芝士的博客
02-20 712
堆栈和单调栈的实现与例题应用
Python之单调栈
四问四不知的博客
09-03 867
了解单调栈先要了解栈。栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。所以它是一种先入后出的数据结构。而单调栈是一种单调递增或单调递减的栈，跟单调队列差不多，但是只用到它的一端。
数据结构之单调栈（按单减栈）
weixin_43036882的博客
05-20 960
1. 单调栈是什么 单调栈是这样一个栈，它里面的元素从栈底到栈顶依次递减。 2. 单调栈怎么生成 假如我们有一个数组nums[n]=[4,2,0,3,2,5]，和一个空的栈stack。 我们遍历数组，对遇到的每一个元素num： 如果栈为空，则将num进栈； 否则，取栈顶元素top与num比较： num 小于top，则将num进栈； 否则，top出栈，新的top与num比较； 下面是栈的变化情况： 4 4 2 4 2 0 4 2 4 3
LeetCode 42. Trapping Rain Water - 单调栈（Monotonic Stack）系列题4
hgq522的博客
01-25 438
题目给定一个非负整数的数组，数组里每个数表示一个宽度为1的柱子的高度，由于柱子之间的高度差就会形成一个个槽位，这样一下雨这些槽位就会装满水。问最多能装多少单位的水？ 先来分析一下什么情况才能装水，两根紧挨着的柱子肯定无法形成槽位，因此至少是三根以上的柱子；要是柱子高度单调递增或递减也无法形成槽位。只有出现一排柱子边上的两根柱子高于中间的柱子才能形成槽位。根据以上分析，跟单调栈的算法很相似，因此可以用单调栈来解答该题。
LeetCode 456. 132 Pattern - 单调栈（Monotonic Stack）系列题6
hgq522的博客
01-27 439
题目给定一个整型数组，问是否存在三个数的子序列满足132模式，所谓132模式就是三个数保持数组中的顺序，第三个数大于第一个数但小于第二个数。这题是一道变形的单调栈类型题，要是不放在单调栈系列里刷是很难想到可以用单调栈的。
LeetCode 739. Daily Temperatures - 单调栈（Monotonic Stack）系列题3
hgq522的博客
01-24 307
这道题其实就是求下一个更大数(Next Greater Number)，只是被包装成气温相关的问法。
使用堆栈实现对算数四则混合运算表达式的求值（C语言）
kuuhakuのblog
04-23 2656
使用堆栈实现对算数四则混合运算表达式的求值（C语言） 一个运算数和运算符之间没有空格的算术表达式字符串，采用堆栈的方法对其进行计算
单调栈和单调队列总结
个人学习记录
03-23 315
总结下面经中常考的栈和队列题目，仅供个人日后复习。 用两个栈实现队列 用两个队列实现栈 根据栈的压入序列能不能得到给定的弹出序列 包含min函数的栈 以上题目告诉我们：要适当构建辅助栈。 另外，还有一种单调栈的简单数据结构。 单调栈实际上就是栈，只是利用了一些巧妙的逻辑，使得每次新元素入栈后，栈内的元素都保持有序（单调递增或单调递减）。单调栈用途不太广泛，只处理一种典型问题，即next greater element。 Leetcode 496：下一个更大元素 I 题目描述： 给你两个 没有重复元素
单调队列与单调栈用法详解
热门推荐
Glory 的 博客
08-27 1万+
基本数据结构的应用一 栈和队列 单调栈 单调队列 和  优先队列的应用 1.单调栈 单调栈是指一个栈内部的元素是具有严格单调性的一种数据结构，分为单调递增栈和单调递减栈。 单调栈有两个性质 1.满足从栈顶到栈底的元素具有严格的单调性 2.满足栈的后进先出特性越靠近栈底的元素越早进栈 元素进栈过程 对于一个单调递增栈来说 若当前进栈的元素为 a 如果a = 当前栈顶元素则不断将栈顶元
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 928
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1216
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 360
JDK1.0主要特性。
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1018
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
Linux堆栈保护与栈溢出攻击防范
"Linux操作系统为了防止基本栈溢出攻击，采用了多种保护机制，包括内存地址随机化、可执行程序的屏蔽保护、gcc编译器的gs验证码机制和ld链接器的堆栈段不可执行机制。这些机制在一定程度上提高了系统的安全性，使得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值