第三章-栈（2）举例应用

最新推荐文章于 2021-08-25 18:03:40 发布
最新推荐文章于 2021-08-25 18:03:40 发布
阅读量478 收藏 10
点赞数 4
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40191710/article/details/79102080
版权

栈的举例应用

--------------------------------------------------------------------------------------------------------------------------------

栈的举例应用1：

----------------------------------------------------------------------------------------------------------------


举例应用2：

       十进制数 N 和其他 d 的进制的转换：

        原 理：   N=( N div d) * d + N mod d (div 为整除运算，mod 为求余运算 )

          例如 ：（1348）10 = （2504）8

          运算过程：

                    N                                N div 8                                N mod 8

                  1348                               168                                       4

                   168                                 21                                        0

                    21                                   2                                         5

                    2                                     0                                         2

代码如下： （注：以 .cpp 为后缀名）

//头文件
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>

//宏定义
#define STACK_INIT_SIZE 100     //存储空间初始分配量
#define STACKINCREMENT 10         //存储空间分配增量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int SElemType;
typedef int Status;

//栈的顺序结构体
typedef struct{
	SElemType *base;              //在栈构造之前和销毁之后，base 的值为NULL;
	SElemType *top;               //栈顶指针
	int stacksize;                //当前已分配的存储空间，以元素为单位
}SqStack;

//1.构建栈
Status InitStack(SqStack &S){
	//构造一个空栈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;
}

//4.判断栈是否为空
Status StackEmpty( SqStack S)
{
	if(S.top==S.base)
		return TRUE;
	else
		return ERROR;
}


//7.栈顶插入元素
Status Push(SqStack &S,SElemType &e)
{       //插入元素 e 为新的栈顶元素
	if(S.top-S.base >= STACK_INIT_SIZE)  //栈满的时候就需要追加存储空间
	{
		S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));	
		if(!S.base)  exit(OVERFLOW);    //存储空间分配失败

		S.top=S.base+S.stacksize;   //栈底的位置可能改变，需要重新定位栈顶元素
		//S.top 还是之前的那个没有存储的位置   

		S.stacksize = S.stacksize+STACKINCREMENT;
	}
	*S.top=e;
	S.top++;
	return OK;
}


//8.栈顶出栈元素
Status Pop(SqStack &S,SElemType &e){
	//若栈不为空，则删除 S 的栈顶元素，用 e 返回其值，并返回 OK ，否则返回ERROR
	if(S.top == S.base)  return ERROR;
	e=*(--S.top);     //可以不加括号，但需要记住的是，需要让 top 指针减 1 ，再取出元素
	return OK;
}
//转换函数：
void conversion(){
	int N,N1,e;
	SqStack S;
	//对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数
	InitStack(S);      //构建空栈
	scanf("%d",&N);
	while(N){    //以 N 不等于 0 为条件
		N1=N%8;
		Push(S,N1);     //入栈，将 N 除于 8 的余数入栈
		N=N/8;
	}
	while( !StackEmpty(S) ){
		Pop(S,e);
		printf("%d",e);
	}
}

void main(){
	conversion();
}


举例应用3：

括号匹配：

如有一下括号序列：

               [  (  [  ]  [  ]  )  ]

              1  2 3 4  5 6 7 8

当计算机接收了第一个括号后，它期待着与其匹配的第八个括号出现，然而等来的是第二个，这是第一个括号入栈，接着迫切等待与第二个匹配的括号，然而等来了第三个，所以第二个入栈，接着第三个入栈，等来了第四个，发现第四个与第三个可以匹配，所以第三个出栈，与其第四个进行匹配成功。接下来一次类推；只要下一个字符能够与出栈的字符进行匹配，就算匹配成功一对字符。如果不能匹配就入栈。

完整代码（注： 后缀名为  .cpp ）


//头文件
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>

//宏定义
#define STACK_INIT_SIZE 100     //存储空间初始分配量
#define STACKINCREMENT 10         //存储空间分配增量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef char SElemType;
typedef char Status;

//栈的顺序结构体
typedef struct{
	SElemType *base;              //在栈构造之前和销毁之后，base 的值为NULL;
	SElemType *top;               //栈顶指针
	int stacksize;                //当前已分配的存储空间，以元素为单位
}SqStack;

//1.构建栈
Status InitStack(SqStack &S){
	//构造一个空栈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;
}

//4.判断栈是否为空
Status StackEmpty( SqStack S)
{
	if(S.top==S.base)
		return TRUE;
	else
		return ERROR;
}


//7.栈顶插入元素
Status Push(SqStack &S,SElemType &e)
{       //插入元素 e 为新的栈顶元素
	if(S.top-S.base >= STACK_INIT_SIZE)  //栈满的时候就需要追加存储空间
	{
		S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));	
		if(!S.base)  exit(OVERFLOW);    //存储空间分配失败

		S.top=S.base+S.stacksize;   //栈底的位置可能改变，需要重新定位栈顶元素
		//S.top 还是之前的那个没有存储的位置   

		S.stacksize = S.stacksize+STACKINCREMENT;
	}
	*S.top=e;
	S.top++;
	return OK;
}


//8.栈顶出栈元素
Status Pop(SqStack &S,SElemType &e){
	//若栈不为空，则删除 S 的栈顶元素，用 e 返回其值，并返回 OK ，否则返回ERROR
	if(S.top == S.base)  return ERROR;
	e=*(--S.top);     //可以不加括号，但需要记住的是，需要让 top 指针减 1 ，再取出元素
	return OK;
}

void bracket(){
	SElemType a[8]={ '[' , '(' , '[' , ']' , '[' , ']' , ')' , ']' };
	SElemType e;
	int n=1;
	SqStack S;
	InitStack(S);
	SElemType *p=a;
	while(*p){
		switch(*p){
		case '[':
		case '(':
			Push(S,*p); //左括号就入栈
			break;

		case ']':
		case ')':
			Pop(S,e);   //有括号就寻找一个出栈来进行匹配
			if( (*p==')' && e=='(') || (*p==']' && e=='[') )
			{  	printf("匹配成功 %d 个\n",n);     n++;    }
			else
			{	printf("匹配不成功");  exit(OVERFLOW);  }
		}
		p++;         //下一个字符 
	}
	if( StackEmpty(S) )    //如果栈已经为空，就证明全都搞定了，所有匹配成功。
		printf("所有括号匹配成功！");
	else
		printf("匹配失败。");
}

void main(){
	bracket();
}

应用举例3：

行编辑程序：


完整代码：

  .cpp 为文件名

//头文件
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>

//宏定义
#define STACK_INIT_SIZE 100     //存储空间初始分配量
#define STACKINCREMENT 10         //存储空间分配增量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef char SElemType;
typedef char Status;

//栈的顺序结构体
typedef struct{
	SElemType *base;              //在栈构造之前和销毁之后，base 的值为NULL;
	SElemType *top;               //栈顶指针
	int stacksize;                //当前已分配的存储空间，以元素为单位
}SqStack;

//1.构建栈
Status InitStack(SqStack &S){
	//构造一个空栈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;
}

//3.清空栈  
Status ClearStack(SqStack &S){  
    S.top=S.base;   //栈顶和栈底指向同一个位置，即为空  
    return OK;  
}  

//4.判断栈是否为空
Status StackEmpty( SqStack S)
{
	if(S.top==S.base)
		return TRUE;
	else
		return ERROR;
}


//7.栈顶插入元素
Status Push(SqStack &S,SElemType &e)
{       //插入元素 e 为新的栈顶元素
	if(S.top-S.base >= STACK_INIT_SIZE)  //栈满的时候就需要追加存储空间
	{
		S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));	
		if(!S.base)  exit(OVERFLOW);    //存储空间分配失败

		S.top=S.base+S.stacksize;   //栈底的位置可能改变，需要重新定位栈顶元素
		//S.top 还是之前的那个没有存储的位置   

		S.stacksize = S.stacksize+STACKINCREMENT;
	}
	*S.top=e;
	S.top++;
	return OK;
}


//8.栈顶出栈元素
Status Pop(SqStack &S,SElemType &e){
	//若栈不为空，则删除 S 的栈顶元素，用 e 返回其值，并返回 OK ，否则返回ERROR
	if(S.top == S.base)  return ERROR;
	e=*(--S.top);     //可以不加括号，但需要记住的是，需要让 top 指针减 1 ，再取出元素
	return OK;
}

void LineEdit(){
	SqStack S;
	char ch;
	//利用字符栈S，从终端接受一行并传送至调用过程的数据取
	InitStack(S);
	ch=getchar();        //从终端接收第一个字符
	while(ch!=EOF){           //EOF为全文结束符
		while(ch!=EOF && ch!='\n'){
			switch(ch){
			case '#':
				Pop(S,ch);  //仅当非空栈时退栈
				break;

			case '@':
				ClearStack(S);    //重置S为空栈 
				break;

			default:
				Push(S,ch);       //其他有效字符，入栈，未考虑栈满的情况
			}
		ch=getchar();       //从终端接收下一个字符
		}
		while( !StackEmpty(S) ){
			Pop(S,ch);
			printf("%c",ch);
		}
		

		ClearStack(S);         //重置栈S为空栈
		if(ch!=EOF) ch=getchar(); 
	}
}

void main(){
	LineEdit();
}

应用举例：

迷宫求解的方法：





完整代码：（文件后缀名为 .cpp ）

//头文件
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>

//宏定义
#define STACK_INIT_SIZE 100     //存储空间初始分配量
#define STACKINCREMENT 10         //存储空间分配增量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

const int M=10;
const int N=10;

//typedef char SElemType;    
typedef char Status;

//迷宫图
int maze[M][N]={
	1,1,1,1,1,1,1,1,1,1,
	1,0,0,1,0,0,0,1,0,1,
	1,0,0,1,0,0,0,1,0,1,
	1,0,0,0,0,1,1,0,0,1,
	1,0,1,1,1,0,0,0,0,1,
	1,0,0,0,1,0,0,0,0,1,
	1,0,1,0,0,0,1,0,0,1,
	1,0,1,1,1,0,1,1,0,1,
	1,1,0,0,0,0,0,0,0,1,
	1,1,1,1,1,1,1,1,1,1,
};

int next_xy[4][2]={ {0,1} , {1,0} , {0,-1} , {-1,0} };    //用于计算下一次搜索位置的计算量

typedef struct{
	int x;
	int y;
}PostType;       //用于记录在迷宫中的位置


typedef struct{
	int ord;             //道路块在路径上的“序号”
	PostType seat;       //道路块在迷宫中的“坐标位置”
	int di;              //从此通道块走向下一通道块的“方向”
}SElemType;            //栈的元素类型


//栈的顺序结构体
typedef struct{
	SElemType *base;              //在栈构造之前和销毁之后，base 的值为NULL;
	SElemType *top;               //栈顶指针
	int stacksize;                //当前已分配的存储空间，以元素为单位
}SqStack;


//1.构建栈
Status InitStack(SqStack &S){
	//构造一个空栈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;
}

//3.清空栈  
Status ClearStack(SqStack &S){  
    S.top=S.base;   //栈顶和栈底指向同一个位置，即为空  
    return OK;  
}  

//4.判断栈是否为空
Status StackEmpty( SqStack S)
{
	if(S.top==S.base)
		return TRUE;
	else
		return ERROR;
}


//7.栈顶插入元素
Status Push(SqStack &S,SElemType &e)
{       //插入元素 e 为新的栈顶元素
	if(S.top-S.base >= STACK_INIT_SIZE)  //栈满的时候就需要追加存储空间
	{
		S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));	
		if(!S.base)  exit(OVERFLOW);    //存储空间分配失败

		S.top=S.base+S.stacksize;   //栈底的位置可能改变，需要重新定位栈顶元素
		//S.top 还是之前的那个没有存储的位置   

		S.stacksize = S.stacksize+STACKINCREMENT;
	}
	*S.top=e;
	S.top++;
	return OK;
}


//8.栈顶出栈元素
Status Pop(SqStack &S,SElemType &e){
	//若栈不为空，则删除 S 的栈顶元素，用 e 返回其值，并返回 OK ，否则返回ERROR
	if(S.top == S.base)  return ERROR;
	e=*(--S.top);     //可以不加括号，但需要记住的是，需要让 top 指针减 1 ，再取出元素
	return OK;
}


//判断当前点是否为可通
int Pass(PostType e){
	int i,j;
	i=e.x;
	j=e.y;
	if(maze[i][j]==0)
		return 1;       //maze[i][j]=0 为可通，返回1
	else
		return 0;       //maze[i][j]=0 为不可通，返回0
}

//为可行的地方留下标记
int FootPrint(PostType e){
	int i,j;
	i=e.x;
	j=e.y;
	maze[i][j]=8;   //进行已经访问的标记，用 8 来表示
	return 1;
}

PostType NextPost(PostType &e,int di){
	e.x=e.x+next_xy[di-1][0];      //已经定义好的 next_xy[4][2]={ {0,1} , {1,0} , {0,-1} , {-1,0} }
	e.y=e.y+next_xy[di-1][1];       //
	return e;
}

//留下不能通过的痕迹
int MarkPrint(PostType e){
	int i,j;
	i=e.x;
	j=e.y;
	maze[i][j]=1;  //不能通过为 1
	return 1;
}

//迷宫计算函数
Status MazePath(int maze[M][N],PostType start,PostType end){  
	//若迷宫 maze 中存在从入口 start 到出口 end 的通道，则求得一条存放在栈中（从栈底到栈顶），并返回TRUE ，否则返回 FALSE 
	SqStack S;         //定义栈S
	PostType currentPsot;     //当前位置
	int curstep=1;          //记载步数的
	SElemType e;
	
	currentPsot=start;        //开始位置
	InitStack(S);

	do{
		if( Pass(currentPsot) ){     //当前位置是否可以通过，即是未曾走到过的通道块
			FootPrint(currentPsot);   //留下足迹

			e.di=curstep;            
			e.seat.x=currentPsot.x;     //记录当前可通节点的情况
			e.seat.y=currentPsot.y;
			e.di=1;            //当前可通结点的访问方向为1，东南西北顺序访问

			Push(S,e);        //加入路径，将当前节点入栈，如果下一步结点不可通可返回上一节点继续
		
			if( currentPsot.x==end.x && currentPsot.y==end.y ){   //如果到了出口终点的时候
				printf("迷宫行走完成！\n");
				return 1;
			}
			currentPsot=NextPost(currentPsot,1);      //下一位置是当前位置的东邻
			curstep++;              //探索下一步
		}
		else{  //当前结点的位置不能通过
			if(!StackEmpty(S)){
				Pop(S,e);     //回到上一个结点
				while(e.di==4 && !StackEmpty(S)){  //当前结点的所有方向都访问过了，且栈不为空，没有路可以走了，只能返回上一步
					MarkPrint(e.seat);
					Pop(S,e);    //出栈 出下一节点 
				}
				if(e.di<4){ //还有其他结点没有访问
					e.di++;   //下一个方向
					Push(S,e);    //先做好存储保护
					currentPsot=NextPost(e.seat,e.di);
				}
			}
		}
	}while( !StackEmpty(S) );    //栈不为空，继续寻找下一个可走的节点
	printf("Unable to find the way through.\n");
	return -1;  //当所有的栈元素出栈以后，栈为空，且没有返回找到的路径，那么说明已经没有其他的路可走，找不到通路
}

void main(){
	int i,j;     //定义
	SqStack S;

	PostType start,end;
	start.x=1;
	start.y=1;    //起点
	end.x=8; 
	end.y=8;      //终点

	printf("The current maze is:\n");
	for(i=0;i<M;i++)
	{
		for(j=0;j<N;j++)
			printf(" %d",maze[i][j]);
		printf("\n");
	}printf("\n");

	MazePath(maze,start,end);    //调用迷宫函数

	for(i=0;i<M;i++)
	{
		for(j=0;j<N;j++)
			printf(" %d",maze[i][j]);
		printf("\n");
	}printf("\n");

}











qq_40191710
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3.2栈的应用举例
suen1987的专栏
08-08 1250
由于栈具有后进先出的特性，所以致使栈成为程序设计中的有用工具。 3.2.1 数制转换 十进制数N和其它d进制数的转换是计算机实现计算的基本问题，解决算法很多，其中一个简单的算法原理如下： N = （N div d）X d + N mod d（其中div为整除运算，mod为求余运算） 例如：10进制与8进制之间的转换； 现在编一个满足下列要求的程序：对于一个任意输入的非负10进制数，打
栈的应用举例（二）
BGnv5
04-02 278
行编辑程序 typedef char SElemType; FILE *fp; void copy(SElemType c){//将字符c送至fp所指的文件中 fputc(c,fp); } void LineEdit(){//利用字符栈s,从终端接收一行并送至调用过程的数据区 SqStack s; char ch; InitStack(s);//初始化栈s printf("请输入...
【数据结构与算法】 栈——栈的应用举例（3例）
TW_345的专栏
11-26 7262
根据“后进先出”特性，生活中的例子比比皆是，本文举3例。 1数制转换 2括号匹配验证 3表达式求值
栈的几个实例应用
heitong_fu的博客
08-25 4458
简单括号匹配 问题描述：括号的使用必须遵循 “平衡”规则，即 首先，每个开括号要恰好对应一个闭括号； 其次，每对开闭括号要正确的嵌套 正确的括号：(()()()())，(((())))， (()((())())) 错误的括号：((((((())，()))，(()()(() 对括号是否正确匹配的识别，是很多语言编译器的基础算法 解题思路：从左到右扫描括号串，最新打开的左括号，应该匹配最先遇到的右括号 这样，第一个左括号（最早打开），就应该匹配 最后一个右括号（最后遇到） 这种次序反转的识别，正好符合栈的特性
数据结构实验之栈一：进制转换
weixin_33814685的博客
01-23 170
题目描述 输入一个十进制整数，将其转换成对应的R（2<=R<=9)进制数,并输出。 输入 第一行输入需要转换的十进制数；第二行输入R。 输出 输出转换所得的R进制数。 示例输入 1279 8 示例输出 2377 提示 View Code 1 #include<stdio.h> 2 #define maxsize 10...
第3章-栈和队列1
08-03
第3章 栈和队列第3章 栈和队列3.1 栈3 2 栈应用举例3.2 栈应用举例3.3 栈与递归函数3.4 队列3.5 队列应用举例3 6 小结3.6 小结栈3.
数据结构 第3章 栈和队列.ppt
06-17
栈的应用举例： 1. 评价表达式的计算 2. 语法分析 3. 进栈出栈的操作 队列是一种特殊的线性表，它限定在表尾进行插入，在表头进行删除操作。队列的特点是先进先出（FIFO）。 队列的抽象数据类型定义（ADT）： ...
第3章 栈和队列---计算机.ppt
11-15
3、栈与队列的应用举例  本章重点难点： 1、栈的存储结构、特点、基本操作算法实现、 以 及栈在递归算法实现中的应用。 2、队列存储结构、特点、基本操作、 算法实现、 循环队列及其应用。
数据结构考研讲义 第三章 栈、队列和数组.pdf
08-31
数据结构考研讲义第三章栈、队列和数组 本资源主要介绍了栈、队列和数组这三种基本数据结构的概念、存储实现、基本操作和应用实例。栈是一种限制在表的一端进行插入和删除的线性表，允许插入、删除的这一端称为栈顶...
第五章 树与二叉树
11-27
性质5-2 在一棵深度为k的二叉树中，最多有2^k-1个结点，最少有k个结点。 性质5-3 在一棵二叉树中，如果叶子结点的个数为n0，度为2的结点个数为n2，则n0=n2+1. 性质5-4 具有n个结点的完全二叉树的深度为【log2^n】+1...
栈的应用举例
曹世宏的博客
10-23 9884
数制转换应用：十进制数N和其他d进制数的转换是计算机实现计算的基本问题，其解决方法很多，其中一个简单算法基于下列原理： N = (N div d) * d + N mod d(其中：div为整除运算，mod为求余运算) 例如，(2007)10 = (3727)8，其运算过程如下：可以看到上述过程是从低位到高位产生8进制的各个数位，然后从高位到低位进行输出，结果数位的使用具有后出现先使用的特点，因
栈的定义及其基本运算
热门推荐
larry233的博客
03-16 1万+
基本定义：栈（Stack）是n个元素a1,a2,…an,组成的有限序列，记作S =(a1,a2,…,an)，并且只能在一端插入和删除元素，n=0时称为空栈。栈的特征：由于栈只能从一端插入和删除元素，故栈具有后进先出（Last in,first out,LIFO）的特性。称插入和删除的一端为栈顶(top)，另一端为栈底(bottom)。称插入元素为入栈或压栈(push)，删除元素为出栈或弹栈(pop)
数据结构（二）栈和栈的应用举例
MyFamily_IT的博客
01-10 657
栈（FILO，先进先出），作为操作受限的特殊线性表，其存储结构与操作算法与一般线性表不相同，这里做一个专门讨论。由于栈作为操作受限的特殊线性表，因此线性表的存储结构对栈也适用，只是操作不同。栈有两种存储结构：顺序栈和链栈。栈有栈顶（TOP）和栈底（base）。对于静态顺序栈来说 ，入栈和出栈相对比较简单，入栈：S【top++】=e。出栈*e = S【--top】。对于链栈，我们有一定的特殊性，程序...
《数据结构与算法 C语言版》—— 3.1栈
weixin_33699914的博客
07-04 217
本节书摘来自华章出版社《数据结构与算法 C语言版》一 书中的第3章，第3.1节，作者：徐凤生，更多章节内容可以访问云栖社区“华章计算机”公众号查看。 3.1栈 3.1.1栈的抽象数据类型定义 栈(stack)是限定仅在表尾进行插入或删除操作的线性表。表尾端称为栈顶，表头端称为栈底。不含元素的栈称为空栈。由于后进栈的元素先出栈，所以栈又称为后进先出(Las...
C++的模板（二）类模板示例三：（栈实现）将输入的一个数（十进制）以任意进制（二进制、八进制、十六进制）输出
qq_47329614的博客
06-29 427
#include <iostream> #include <cstdio> #include <cstdlib> using namespace std; template <typename T> class Stack{ private: int size; int max_size; T *tp; public: Stack(int size){ max_size=size; tp=new T[size]; this->
栈的应用实例--数制转换（第三章 P48 算法3.1）
但行好事，莫问前程
03-20 1644
栈的应用实例--数制转换 题目： 假设 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */ typedef int SElemType; /* 定义栈元素的类型 */ #include<malloc.h...
一个菜鸟的数据结构学习之路（栈篇）
qq_42014895的博客
06-06 1561
栈的基本操作如下： 相关结构体： typedef int status; typedef struct { SElemType *base; //在栈创建之前和销毁之后，base的值为NULL SElemType *top; //栈顶指针 int stacksize; //当前已分配的储存空间，以元素为单位 }SqStack; 相关宏定义： # def...
数据结构——栈的应用举例
程序员的修养
02-27 694
本文所有代码均为伪码，仅阐述算法基本思想——《数据结构》清华大学出版社 - 算法1 对于输入的任意一个非负十进制整数，打印输出与其等值的N进制数 #define N 8 // 定义待转换的进制N(2～9) typedef int SElemType; // 定义栈元素类型为整型 void conversion() { SqStack s; unsigned n; /
off-policy应用举例
最新发布
03-09
off-policy的应用举例包括：Q-learning、SARSA、Deep Q-Network等强化学习算法中的经验回放机制，以及基于策略梯度的算法中的重要性采样等。此外，在推荐系统中，off-policy也可以用于评估不同推荐策略的效果，以及...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值