顺序栈的基本操作及应用

最新推荐文章于 2023-01-04 15:19:52 发布
最新推荐文章于 2023-01-04 15:19:52 发布
阅读量7.5k 收藏 79
点赞数 13
分类专栏： 头歌实践教学平台 C 文章标签： 顺序栈 进制转换 回文判断 栈操作 数据结构
原文链接：https://blog.csdn.net/Junds0/article/details/124556715
版权
该博客介绍了如何使用顺序栈实现顺序栈的基本操作，包括判断栈是否为空、获取栈顶元素、进栈和出栈等。此外，还展示了两个实际应用：一是利用顺序栈将十进制数转换为十六进制，二是通过栈判断字符串是否为回文。顺序栈在这些应用场景中表现出高效和简洁的特点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第1关：顺序栈的基本操作

任务描述

本关任务是实现顺序栈的基本操作函数，以实现判断栈是否为满、是否为空、求栈元素个数、进栈和出栈等功能。

测试说明

平台会对你编写的代码进行测试：

测试输入：
12
12 47 5 8 6 92 45 63 75 38 4 29

预期输出：
栈中元素依次为：12 47 5 8 6 92 45 63 75 38 4 29
弹出的栈顶元素 e=29
栈空否：0(1:空 0:否)
栈顶元素 e=4 栈的长度为11
清空栈后，栈空否：1(1:空 0:否)
销毁栈后，s.top=0 s.base=0 s.stacksize=0

输入说明
第一行输入顺序栈的数据元素的个数n；
第二行输入顺序栈的n个整数。

输出说明
第一行输出顺序栈的所有数据元素；
第二行输出出栈的数据元素；
第三行判断栈是否为空；
第四行输出当前的栈顶元素及栈的长度；
第五行清空栈后，判断栈是否为空；
第六行销毁栈后输出栈顶、栈底及栈的容量。

代码如下

#include <stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;

 // 函数结果状态代码
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define OVERFLOW -1
 
#define  STACK_INIT_SIZE   100  //存储空间初始分配量 
#define  STACK_INCREMENT    10   //存储空间分配增量  
typedef int SElemType; // 定义栈元素类型为整型
/* 顺序栈类型定义 */
typedef   struct
{          
    SElemType     *base;    //栈的基址即栈底指针          
    SElemType     *top;     //栈顶指针          
   int      stacksize;       //当前分配的空间 
}SqStack; 

void input(SElemType &s);
void output(SElemType s);

void InitStack(SqStack &S);// 构造一个空栈S
void DestroyStack(SqStack &S); // 销毁栈S，S不再存在
void ClearStack(SqStack &S); // 把S置为空栈
int StackEmpty(SqStack S); // 若栈S为空栈，则返回TRUE，否则返回FALSE
int StackLength(SqStack S); // 返回S的元素个数，即栈的长度
int GetTop(SqStack S,SElemType &e);  // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
void Push(SqStack &S,SElemType e);    // 插入元素e为新的栈顶元素
int Pop(SqStack &S,SElemType &e);   // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
void StackTraverse(SqStack S,void(*visit)(SElemType)); // 从栈底到栈顶依次对栈中每个元素调用函数visit()


int main()
 {
   int j;
   SqStack s;
   SElemType e;
   InitStack(s);
   int i;
   cin>>i;
   for(j=0;j<i;j++)  
   {  
       input(e);  
       Push(s,e);  
   }  
   printf("栈中元素依次为：");
   StackTraverse(s,output);
   Pop(s,e);
   printf("弹出的栈顶元素 e=%d\n",e);
   printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));
   GetTop(s,e);
   printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));
   ClearStack(s);
   printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));
   DestroyStack(s);
   printf("销毁栈后，s.top=%u s.base=%u s.stacksize=%d\n",s.top,s.base, s.stacksize);
 }
/*****SElemType类型元素的基本操作*****/
void input(SElemType &s)
{
    cin>>s;
}
void output(SElemType s)
{
    cout<<s<<" ";
}

/*****顺序栈的基本操作*****/
void InitStack(SqStack &S)
{ 
	// 构造一个空栈S
    /********** Begin **********/ 
    S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S.base) exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    /********** End **********/  
}

void DestroyStack(SqStack &S)
{ 
	// 销毁栈S，S不再存在
    /********** Begin **********/ 
    free(S.base);
    free(S.top);
    S.base=NULL;
    S.top=NULL;
    S.stacksize=0;
    /********** End **********/ 	
}

void ClearStack(SqStack &S)
{ 
 	// 把S置为空栈
    /********** Begin **********/ 
    S.base=NULL;
    S.top=NULL;
    S.stacksize=0;

    /********** End **********/ 
}


int StackEmpty(SqStack S)
{
 	// 若栈S为空栈，则返回TRUE，否则返回FALSE
    /********** Begin **********/ 
    if(S.top==S.base)
        return TRUE;
    else
        return FALSE;
    /********** End **********/	
 }


int StackLength(SqStack S)
{ 
	// 返回S的元素个数，即栈的长度
    /********** Begin **********/ 
    return S.top-S.base;

    /********** End **********/  
}


int GetTop(SqStack S,SElemType &e)
{ 
    // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
    /********** Begin **********/ 
    if(S.top!=S.base){
        e=*(S.top-1);
        return OK;
    }else{
        return ERROR;
    }
    /********** End **********/	
}


void Push(SqStack &S,SElemType e)
{     
	// 插入元素e为新的栈顶元素
    /********** Begin **********/ 
    if((S.top-S.base)>=S.stacksize){
        S.base=(SElemType *)realloc(S.base,(S.stacksize+STACK_INCREMENT)*sizeof(SElemType));
        if(!S.base)
            exit(OVERFLOW);
        S.top=S.base+S.stacksize;
        S.stacksize+=STACK_INCREMENT;
    }
    *(S.top)++=e;
    /********** End **********/	
}

int Pop(SqStack &S,SElemType &e)
{   
	// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
    /********** Begin **********/ 
    if(S.top==S.base)
        return ERROR;
    e=*--S.top;
    return OK;
    /********** End **********/ 	
}

void StackTraverse(SqStack S,void(*visit)(SElemType))
{ 
	// 从栈底到栈顶依次对栈中每个元素调用函数visit()
    /********** Begin **********/ 
    while(S.base!=S.top){
        visit(*S.base++);
    }
    printf("\n");

    /********** End **********/	
}

第2关：栈的应用-进制转换

任务描述

本关任务：利用顺序栈将一个非负的十进制整数N转换为对应的十六进制数。非负的十进制整数N从键盘输入，转换结果从屏幕输出。

测试说明

平台会对你编写的代码进行测试：

测试输入：10
预期输出：A

测试输入：100
预期输出：64

代码如下

#include <stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;

typedef int SElemType; // 定义栈元素类型为整型

#include "sqstack.h"  // 顺序栈的类型定义

void conversion(unsigned n)
{ 
	// 对于输入的任意一个非负10进制整数，打印输出与其等值的16进制数
   /********** Begin **********/ 
	if(n>0){
      conversion(n/16);

      if(n%16<10)
         putchar('0'+n%16);
      else
         putchar('A'+n%16-10);
   }
   
	/********** End **********/	
}

int main()
{  
    unsigned n; // 非负整数
    scanf("%u",&n); // 输入非负十进制整数n
    conversion(n);
 }

第3关：栈的应用-回文的判断

任务描述

本关任务：若一个字符串的正序与倒序相同，则称其为回文字符串。现在输入一个字符串，使用栈判断它是否是回文字符串。

测试说明

平台会对你编写的代码进行测试：

测试输入：
thisistrueurtsisiht
预期输出：
thisistrueurtsisiht
YES

测试输入：
thisisnottrue
预期输出：
thisisnottrue
NO

输入格式:
在一行中给出一个不超过80个字符长度的、以回车结束的非空字符串。

输出格式:
在第1行中输出字符串。如果它是回文字符串，在第2行中输出YES，否则输出NO。

代码如下

#include<stdio.h>
#include<string.h>
// 添加以下两行
#include <iostream>
using namespace std;

#include"sqstack.h"    //头文件sqstack.h为顺序栈的定义和基本操作的实现

typedef char SElemType;// 定义栈元素类型为字符型

# define MAXSIZE  80

int isHuiWei(char *s){
	int i,j,m1,m2;
	m1=strlen(s)/2;
	m2=strlen(s)%2==0?m1:m1+1;
	for(i=0,j=strlen(s)-1;i<m1,j>=m2;i++,j--){
		if(s[i]!=s[j]) return 0;
	}
	return 1;
}

int main()
{
	/********** Begin **********/ 
	char s[80];
	cin >> s;
	int i;
	for(i=0;i<strlen(s);i++)
		putchar(s[i]);
	if(isHuiWei(s)) printf("\n%s","YES");
	else printf("\n%s","NO");
	/********** End **********/	
	return 0;
}

辅助文件

sqstack.h

#ifndef   __SQSTACK_H__
#define   __SQSTACK_H__
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1

#define  STACK_INIT_SIZE   100  //存储空间初始分配量 
#define  STACKINCREMENT    10   //存储空间分配增量  

typedef char SElemType; // 定义栈元素类型为整型

typedef   struct
{          
    SElemType     *base;    //栈的基址即栈底指针          
    SElemType     *top;     //栈顶指针          
   int      stacksize;       //当前分配的空间 
}SqStack; 
void InitStack(SqStack &S);
void DestroyStack(SqStack &S);
void ClearStack(SqStack &S);
int StackEmpty(SqStack S);
int StackLength(SqStack S);
int GetTop(SqStack S,SElemType &e);
void Push(SqStack &S,SElemType e);
int Pop(SqStack &S,SElemType &e);
void StackTraverse(SqStack S,void(*visit)(SElemType));
#endif

sqstack.cpp

#include<stdio.h>
#include<stdlib.h>
#include"sqstack.h" 
typedef char SElemType; // 定义栈元素类型为整型
void InitStack(SqStack &S)
{ 
	if(!(S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType))))
     exit(OVERFLOW); // 存储分配失败
    S.top=S.base;
	S.stacksize=STACK_INIT_SIZE; 
}

void DestroyStack(SqStack &S)
{ 
	free(S.base);
	S.base=NULL;
	S.top=NULL;
	S.stacksize=0; 
}

void ClearStack(SqStack &S)
{ 
	S.top=S.base;
}

int StackEmpty(SqStack S)
{
	if(S.top==S.base)
     return TRUE;
	else
     return FALSE; 	
 }

int StackLength(SqStack S)
{ 
	return S.top-S.base;
}

int GetTop(SqStack S,SElemType &e)
{ 
	if(S.top>S.base)
   {
     e=*(S.top-1);
     return OK;
   }
   else
     return ERROR;
 }

void Push(SqStack &S,SElemType 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; 
}

int Pop(SqStack &S,SElemType &e)
{ 
	if(S.top==S.base)
     return ERROR;
	e=*--S.top;
	return OK;
}

void StackTraverse(SqStack S,void(*visit)(SElemType))
{
	while(S.top>S.base)
		visit(*S.base++);
	printf("\n");
}
浮点数类型：单精度浮点数和双精度浮点数介绍（Java）
CdiBug的博客
09-27 1272
本文介绍了Java中的浮点数类型，包括单精度浮点数和双精度浮点数。在Java编程语言中，浮点数类型包括单精度浮点数（float）和双精度浮点数（double）。本文将介绍这两种浮点数类型的特点和使用方法，并给出相应的源代码示例。如果需要更高的精度，可以选择双精度浮点数。双精度浮点数是一种64位的浮点数类型，用于表示具有更高精度的实数。在Java中，双精度浮点数的关键字是"double"。单精度浮点数是一种32位的浮点数类型，用于表示具有小数部分的实数。在Java中，单精度浮点数的关键字是"float"。
单精度float和双精度double
还在路上的蒲公英
12-13 2284
float为单精度实数，double为双精度实数 float的精度是6位有效数字，取值范围是10的-38次方到10的38次方，float占用4字节空间 double的精度是15位有效数字，取值范围是10的-308次方到10的308次方,double占用8字节空间。 1、单精度，也就是 float ，在 32 位机器上用 4 个字节来存储的；而双精度double是用 8 个字节来存储的，这
单精度浮点数（float）与双精度浮点数（double）的区别
热门推荐
Wood的博客
10-30 7万+
【转载】 单精度浮点数（float）与双精度浮点数（double）的区别如下： （1）在内存中占有的字节数不同 •单精度浮点数在机内占4个字节 •双精度浮点数在机内占8个字节 （2）有效数字位数不同 •单精度浮点数有效数字8位 •双精度浮点数有效数字16位 （3）所能表示数的范围不同 •单精度浮点的表示范围：-3.40E+38 ~ +3.40E+3
单精度浮点数和双精度浮点数有什么区别
qq_31119443的博客
10-20 1万+
单精度浮点数和双精度浮点数有什么区别
单精度浮点数（float）与双精度浮点数（double）的区别:
Perseverance001的博客
07-27 5465
1、单精度，也就是 float ，在 32 位机器上用 4 个字节来存储的；而双精度double是用 8 个字节来存储的，这是他们最本质的区别。  2、由于存储位不同，8位，16位他们能表示的数值的范围就不同，也就是能准确表示的数的位数就不同。 单精度浮点的表示范围：-3.40E+38 ~ +3.40E+38 双精度浮点的表示范围：-1.79E+308 ~ +1.79E+308  ...
单精度浮点数和双精度浮点数的区别
糖哲睿的博客
01-27 7965
在蓝桥杯试题计算圆的面积时使用float表示的范围较小，出现负值。应使用double
c语言浮点数乘法算法,单精度浮点数乘法的实现
weixin_39977586的博客
05-18 2167
按：计算机组成课程第四周作业算法证明 图表 1 浮点数的表示浮点数的表示如上图所示，我们要做的是将按如上方式存储的两个浮点数相乘，将其结果用如上的方式表示。符号位只是两者的异或，指数位基本上是两指数的相加，而尾数位就需要在正常的乘法之余考虑到移位(和随之而来的指数为的溢出)和进位的情况。下面就来讨论一下尾数的运算：在尾数前补上1，进行无符号数乘法。小数点仅作为算法分析时的记号，实际上不...
单精度和双精度浮点型C语言
最新发布
03-14
### C语言中单精度和双精度浮点型的区别及用法 #### 数据类型定义与区别 在C语言中，`float` 和 `double` 是两种用于表示实数的数据类型。它们的主要区别在于存储空间大小以及数值范围和精确度。 - **单精度浮点型...
轻松掌握十六进制数转换为浮点数的方法
比如，IEEE 754标准中单精度浮点数占用32位，双精度浮点数占用64位。 3. 拆分十六进制数到各部分：将十六进制数拆分成相应的位段。对于单精度浮点数，通常会分为1位符号位、8位指数位和23位尾数位；对于双精度...
浮点数和阶码是什么关系
05-27
例如，IEEE 754标准中单精度浮点数的阶码使用127作为偏置值，双精度浮点数的阶码使用1023作为偏置值。 浮点数的有效位数和指数范围是由尾数和阶码的位数决定的。例如，IEEE 754标准中单精度浮点数的尾数有23位，阶...
单精度双精度浮点数转换
05-02
单精度双精度浮点数转换，浮点数与16进制转换工具
C/C++学习记录--double和float的区别
Burning_blade的博客
05-18 2397
单精度浮点数（float）与双精度浮点数（double）的区别如下：（1）在内存中占有的字节数不同单精度浮点数在机内占4个字节双精度浮点数在机内占8个字节（2）有效数字位数不同单精度浮点数有效数字8位双精度浮点数有效数字16位（3）所能表示数的范围不同单精度浮点的表示范围：-3.40E+38 ~ +3.40E+38双精度浮点的表示范围：-1.79E+308 ~ +1.79E+308（4）在程序中处...
单精度浮点数与双精度浮点数区别
gaily123的博客
04-06 4万+
单精度浮点数与双精度浮点数区别 1、所占的内存不同 单精度浮点数占用4个字节（32位）存储空间来存储一个浮点数，包括符号位1位，阶码8位，尾数23位。 而双精度浮点数使用 8个字节（64位）存储空间来存储一个浮点数，包括符号位1位，阶码11位，尾数52位。 2、所存的数值范围不同 单精度浮点数的数值范围为-3.4E38～3.4E38，而双精度浮点数可以表示的数字的绝对值范围大约是：-2.23E30...
实型和浮点型的区别
weixin_42593130的博客
01-04 3910
实型和浮点型是两种不同类型的数据，它们在存储和表示方面有着明显的区别。 实型(又称为整型或整数型)是指不带小数点的数字，例如：0, 1, -10, 100000。实型在计算机内部以二进制的形式存储，其存储空间的大小和数据范围取决于所使用的机器字长(即每个字节所能表示的位数)。 浮点型(又称为单精度浮点型或双精度浮点型)是指带有小数点的数字，例如：3.14, 0.01, -0.5, 100.001。...
计算机浮点数的格式，单精度与双精度的区别
沙丁鱼鱼鱼
01-14 9448
在C/C++中float是32位的，double是64位的，两者在内存中的存储方式和能够表示的精度均不同，目前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。 无论是float还是double，在内存中的存储主要分成三部分，分别是： （1）符号位（Sign）：0代表正数，1代表负数 （2）指数位（Exponent）：用于存储科学计数法中的指
关于单精度和双精度实数
IT___power的专栏
02-18 5286
用科学计数法表示双精度实数: #include int main() { double a=498465468.549; printf("%e",a); //标准指数形式输出单，双精度数（科学计数法） //数字部分小数位数为6位，小数末位四舍五入，指数支持3位 //不支持整数 return
单精度与双精度
卿本佳人的博客
02-10 3万+
单精度： 都包含三个部分：符号位，指数位和尾数部分。单精度是1位符号，8位指数，23位小数。 单精度和双精度精确的范围不一样：单精度，也即float，一般在计算机中存储占用4字节，也32位，有效位数为7位； 精度主要取决于尾数部分的位数，float为23位，所以float小数部分只能精确到后面6位，加上小数点前的一位，即有效数字为7位。 单精度浮点数的数值范围为-3.4乘以10的38次方～3.4乘以10的38次方（-3.4E38～3.4E38）。 双精度： 双精度是1位符号，11位指数，52位小数。
浮点型(float)和实型(real)_什么是浮点？
weixin_39731807的博客
11-27 2万+
是指浮点数以及浮点计算。浮点型简单讲就是实数的意思。浮点数在计算机中用以近似表示任意某个实数。浮点计算是指浮点数参与浮点计算的运算，这种运算通常伴随着因为无法精确表示而进行的近似或舍入。例如，一个指数范围为±4的4位十进制浮点数可以用来表示43210，4.321或0.0004321，但是没有足够的精度来表示432.123和43212.3(必须近似为432.1和43210)。当然，实际使用的位数通常...
MATLAB中的双精度浮点数与单精度浮点数分析
标题中提及的“ex201.rar_arrivehml_双精度浮点_双精度浮点数_浮点数”暗示了本资源与Matlab编程相关，并特别关注于双精度浮点数的处理与理解。从描述来看，该Matlab程序专注于双精度浮点数与单精度浮点数的比较和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值