编程实训-栈

最新推荐文章于 2024-09-07 23:49:10 发布
最新推荐文章于 2024-09-07 23:49:10 发布
阅读量809 收藏 7
点赞数 21
分类专栏： 编程实训-栈1 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77276656/article/details/137069982
版权

                                    第1关：基于栈的中缀算术表达式求值

任务描述

本关任务：输入一个中缀算术表达式，求解表达式的值。运算符包括+、-、*、/、(、)、=，参加运算的数为double类型且为正数。（要求：直接针对中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可。）

编程要求

输入

多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。参加运算的数为double类型。

输出

对于每组数据输出一行，为表达式的运算结果。输出保留两位小数。

测试说明

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

测试输入： 2+2= 20*(4.5-3)= =

预期输出： 4.00 30.00

开始你的任务吧，祝你成功！

#include <iostream>
#include<iomanip>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//运算符栈
    char *base;
	char *top;
	int stacksize;
}SqStack1;
int InitStack1(SqStack1 &S)
{//运算符栈初始化
	S.base=new char[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push1(SqStack1 &S, char e)
{//运算符栈入栈
	if(S.top-S.base==S.stacksize)  //栈满
		return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop1(SqStack1 &S)
{//运算符栈出栈
	if(S.top==S.base)      //栈空
		return ERROR;
	S.top--;
	return OK;
}
char GetTop1(SqStack1 S)
{//运算符栈取栈顶元素
	if(S.top!=S.base)
		return *(S.top-1);
  	return ERROR;
}
typedef struct
{//操作数栈
	double *base;
	double *top;
	int  stacksize;
}SqStack2;
int InitStack2(SqStack2 &S)
{//操作数栈初始化
	S.base=new double[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push2(SqStack2 &S,double e)
{//操作数栈入栈
	if(S.top-S.base==S.stacksize)     //栈满
        return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop2(SqStack2 &S)
{//操作数栈出栈
	if(S.top==S.base)           //栈空
		return ERROR;
	S.top--;
	return OK;
}
double GetTop2(SqStack2 S)
{//操作数栈取栈顶元素
	if(S.top!=S.base)
		return *(S.top-1);
  	return ERROR;
}
double Calculate(double a,char op,double b)
{//计算表达式“a op b”的值
    switch(op)
    {
        case '+':return a+b;
        case '-':return a-b;
        case '*':return a*b;
        case '/':return a/b;
    }
}

char Precede(char a,char b)
{//比较运算符a和b的优先级
	if((a=='('&&b==')')||(a=='='&&b=='='))
		return '=';
	else if(a=='('||a=='='||b=='('||(a=='+'||a=='-')&&(b=='*'||b=='/'))
		return '<';
	else
		return '>';
}


double EvaluateExpression(SqStack1 OPTR,SqStack2 OPND,char s[])
{//算术表达式求值的算符优先算法
	/**************begin************/
    int i,x=0,e=0,flag=0;
	for(i=0;s[i]!='\0';i++){
		if('0'<=s[i]&&s[i]<='9'){
			flag = 1;
			x=x*10+(s[i]-'0');
			if(e!=0) e=e*10;
		}else if(s[i]=='.'){
			e = 1;
		}else{
			if(flag!=0){
				double number = x;
				if(e!=0) number = number/e;
				Push2(OPND,number);
				x=e=flag=0;
			}
			while(1){
				if(Precede(GetTop1(OPTR),s[i])=='<'){
					Push1(OPTR,s[i]);
					break;
				}else if(Precede(GetTop1(OPTR),s[i])=='>'){
					double b = GetTop2(OPND);
					Pop2(OPND);
					double a = GetTop2(OPND);
					Pop2(OPND);
					char oper = GetTop1(OPTR);
					Pop1(OPTR);
					Push2(OPND,Calculate(a,oper,b));
				}else{
					Pop1(OPTR);
					break;
				}
			}
		}
	}	
	return GetTop2(OPND);

		/**************end************/
}


int main()
{//设OPTR和OPND分别为运算符栈和操作数栈
	SqStack1 OPTR;
	InitStack1(OPTR);    //初始化OPND栈
	SqStack2 OPND;
	InitStack2(OPND);    //初始化OPTR栈
	Push1(OPTR,'=');     //将表达式起始符“=”压入OPTR栈        
	char s[100];
	while(cin>>s)
	{//循环读入多组数据
		if(s[0]=='=') 
		   break;    //当表达式只有一个“=”时，输入结束 
		//输出中缀算术表达式的值
		cout<<fixed<<setprecision(2)<<EvaluateExpression(OPTR,OPND,s)<<fixed<<setprecision(2)<<endl;
		
	}
	return 0;
}

                        
                        第2关：双栈的基本操作

        

任务描述

本关任务：将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空；当第1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长（见下图）。试编写双栈初始化，判断栈空、栈满、进栈和出栈算法的函数。函数调用次序依次为：进栈、栈满的判断、出栈、栈空的判断。

双栈数据结构的定义如下：

typedef struct

{

int top[2], bot[2]; //栈顶和栈底指针

SElemType *V; //栈数组

int m; //栈最大可容纳元素个数

}DblStack;

编程要求

输入

多组数据，每组数据有四行，每行的数据之间均用空格分隔。第一行为一个整数m，表示数组V的大小，第二行为四个整数e0、e1、d0、d1，e0和e1分别代表压入0号栈和1号栈的整数序列E0和E1的长度（依次连续入栈，中间没有出栈的情况），d0和d1分别代表从0号栈和1号栈弹出的序列的长度（依次连续出栈，中间没有入栈的情况）。第三行和第四行分别表示序列E0和E1。当m=0时，输入结束。

输出

对于每组数据输出三行。第一行代表进栈操作完成时栈是否为满（出栈操作尚未执行），栈满输出1，栈不满输出0。第二行和第三行的数据分别对应0号栈和1号栈。第二行包括d0+1个整数，其中前d0个整数代表出栈序列D0，最后一个整数代表出栈操作完成时0号栈是否为空，栈空输出0，不空输出1。第三行包括d1+1个整数，其中前d1个整数代表出栈序列D1，最后一个整数代表出栈操作完成时1号栈是否为空，栈空输出0，不空输出1。整数之间用空格分隔。

测试说明

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

测试输入： 7 3 4 2 2 1 2 3 2 3 4 5 12 4 6 4 3 1 3 4 5 1 3 5 6 8 1 0

预期输出： 1 3 2 1 5 4 1 0 5 4 3 1 0 1 8 6 1

#include<iostream>
using namespace std;
typedef struct
{
	int top[2],bot[2];//栈顶和栈底指针
	int *V;//栈数组
	int m;//栈最大可容纳元素个数
}DblStack;
void InitDblStack(DblStack &S,int m)
{//初始化一个大小为m的双向栈
	S.V=new int[m];            //动态分配一个最大容量为m的数组空间
	S.bot[0]=-1;               //左栈栈底指针
	S.bot[1]=m;                //右栈栈底指针
	S.top[0]=-1;               //左栈栈顶指针
	S.top[1]=m;               //右栈栈顶指针
}
int IsEmpty(DblStack S,int i)
{//判断指定的i号栈是否为空，空返回1，否则返回0
	return S.top[i]==S.bot[i];
}
int IsFull(DblStack S)
{//判断栈是否满，满则返回1，否则返回0
	if(S.top[0]+1==S.top[1]) return 1;
	else return 0;
}
void Push(DblStack &S,int i)
{//向指定的i号栈中插入元素x，先移动指针再入栈
	/**************begin************/
    //插入元素，得考虑是否栈满
    if(S.top[0]+1 == S.top[1]) return;
    int x;
    cin>>x;
    if(i==0) S.top[i]++;
    else S.top[i]--;
    S.V[S.top[i]] = x;


	/**************end************/
}

void Pop(DblStack &S,int i)
{//删除指定的i号栈的栈顶元素，先出栈再移动指针
	/**************begin************/
    if(S.top[i] == S.bot[i]) return; //栈空
    cout<<S.V[S.top[i]]<<" ";
    if(i==0) S.top[i]--;
    else S.top[i]++;


	/**************end************/
}
int main()
{
  	DblStack S;
	int m,e0,e1,d0,d1;
	while(cin>>m)
	{
		if(m==0) break;
		InitDblStack(S,m);
      	cin>>e0>>e1>>d0>>d1;
		while(e0--)
			Push(S,0);
		while(e1--)
			Push(S,1);
      	cout<<IsFull(S)<<endl;
		while(d0--)
			Pop(S,0);
      	cout<<!IsEmpty(S,0)<<endl;
		while(d1--)
			Pop(S,1);
      	cout<<!IsEmpty(S,1)<<endl;
	}
	return 0;
}


第3关：基于栈的回文字符序列判断

任务描述

本关任务：回文序列是正反读均相同的字符序列,如“abba”和“abdba”均是回文，但是“good”不是回文。请设计一个算法判定给定的字符序列是否为回文。

编程要求

输入

多组数据，每组数据有一行。每一行为一个长度不定的字符序列A。当A为“0”时，输入结束。

输出

对于每组数据输出一行。若字符序列A是回文序列，则输出“YES”，否则输出“NO”。

测试说明

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

测试输入： abba abdba good 0

预期输出： YES YES NO

#include <iostream>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{
    char *base;
	char *top;
	int stacksize;
}SqStack;
int InitStack(SqStack &S)
{//栈初始化
	S.base=new char[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push(SqStack &S, char e)
{//入栈
	if(S.top-S.base==S.stacksize)  //栈满
		return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop(SqStack &S)
{//出栈返回栈顶元素
	if(S.top==S.base)      //栈空
		return ERROR;
	S.top--;
	return *S.top;
}
int IsPalindrome(SqStack &S,char *t)
{//判断栈的回文字符序列
	/**************begin************/
    //1.入栈 2.按正常判断回文的思路走
    //出栈入栈的代码要烂熟于心
    int len = 0;
    for (int i = 0; t[i] != '\0'; i++) { // 先将输入字符串的所有字符压入栈中  
        Push(S, t[i]);  
        len++;
    }  
    for(int i = 0;i < len/2;i++){
        if(t[i] != Pop(S)) return 0;
    }
    return 1;


	/**************end************/
}
int main()
{
  	char t[100];
	while(cin>>t&&t[0]!='0')
	{
		SqStack S;
		InitStack(S);
		if(IsPalindrome(S,t)==1) cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
	return 0;
}

第4关：入栈和出栈的基本操作

任务描述

本关任务：输入一个整数序列a1,a2,a3...,an。当ai不等于-1时将ai进栈；当ai=-1时，输出栈顶元素并将其出栈。

编程要求

输入

多组数据，每组数据有两行，第一行为序列的长度n，第二行为n个整数，整数之间用空格分隔。当n=0时输入结束。

输出

对于每一组数据输出若干行。每行为相应的出栈元素。当出栈异常时，输出“POP ERROR”并结束本组数据的输出。

测试说明

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

测试输入： 5 1 2 -1 -1 1 5 1 -1 -1 2 2 0

预期输出： 2 1 1 POP ERROR

#include<iostream>
using namespace std;
#define  MAXSIZE  100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef struct
{
	int *base;
	int *top;
	int stacksize;
}SqStack;
int InitSqStack(SqStack &S)
{//栈的初始化
	S.base=new int[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push(SqStack &S,int e)
{//入栈
	if(S.top-S.base==S.stacksize)  //栈满
		return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop(SqStack &S)
{//出栈
	if(S.top==S.base)  //栈空
		return ERROR;
	S.top--;
	return OK;
}
int GetTop(SqStack S)
{//取栈顶元素
	if(S.top==S.base)  //栈空
		return ERROR;
  	return *(S.top-1);
}
void InOutS(SqStack &S,int a[],int n)
{//入栈和出栈的基本操作
	/**************begin************/
    for(int i = 0;i < n;i++){
        if(a[i]!=-1) Push(S,a[i]);
        else{
            if(S.top!=S.base){
                cout<<GetTop(S)<<endl;
                Pop(S);
            }else{
                cout<<"POP ERROR"<<endl;
                return;
            }
        }
    }
	
		/**************end************/
}
int main()
{
	int n;
	while(cin>>n)
	{
      	if(n==0) break;
      	SqStack S;
		InitSqStack(S);
		int a[n];
		for(int i=0;i<n;i++) cin>>a[i];  //整数序列
		InOutS(S,a,n);
	}
	return 0;
}

第5关：基于栈的后缀算术表达式求值

任务描述

本关任务：从键盘上输入一个后缀表达式，试编写算法计算表达式的值。规定：后缀表达式的长度不超过一行，以“=”作为输入结束，操作数之间用空格分隔，操作符只可能有+、?、*、/四种运算。

编程要求

输入

多组数据，每组数据一行，对应一个后缀算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。

输出

对于每组数据输出一行，为表达式的运算结果。

测试说明

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

测试输入： 1 2+8 2-7 4-/*= 1 2+= 1 2/= =

预期输出： 6.00 3.00 0.50

#include <iostream>
#include<iomanip>
#include <string>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//数字栈
	double *base;
	double *top;
	int  stacksize;
}SqStack;
int InitStack(SqStack &S)
{//数字栈初始化
	S.base=new double[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push(SqStack &S,double e)
{//数字栈入栈
	if(S.top-S.base==S.stacksize)  //栈满
        return ERROR;
	*S.top=e;
	S.top++;
	return OK;
}
int Pop(SqStack &S)
{//数字栈出栈
	if(S.top==S.base)    //栈空
		return ERROR;
	S.top--;
	return OK;
}
double GetTop(SqStack S)
{//数字栈取栈顶元素
	if(S.top!=S.base)
		return *(S.top-1);
  	return ERROR;
}
double Calculate(double a,char op,double b)
{//算术表达式的求值
    switch(op)
    {
        case '+':return a+b;
        case '-':return a-b;
        case '*':return a*b;
        case '/':return a/b;
    }
}
double EvaluateExpression(SqStack OPND,char s[])
{//后缀算术表达式求值
	/**************begin************/
    //后缀算术表达式求值
int i,x=0,e=0,flag=0;
        //x和e辅助存储double型数
        //flag用于判断某个double类型数据是否读入完全
        for(i=0;s[i]!='=';i++)
        {
            if('0'<=s[i]&&s[i]<='9')
            {
                flag=1;
                x=x*10+(s[i]-'0');//x存储去掉小数点后的数据，如原数据1.23，最终得到的x为123
                if(e!=0) e=e*10;//小数点后有几位，e扩大为10的几倍
            }
            else if(s[i]=='.')
                e=1;
            else
            {
                if(flag!=0)
                {
                    double number=x;
                    if(e!=0) number=number/e;//如果其间有小数点出现,number缩小对应的倍数
                    Push(OPND,number);//将double类型数据入栈
                    x=e=flag=0;//复原x、e、flag
                }
                if(s[i]==' ') continue;
                double b=GetTop(OPND);
                Pop(OPND);
                double a=GetTop(OPND);
                Pop(OPND);
                char oper=s[i];
                Push(OPND,Calculate(a,oper,b));//将运算结果压入数字栈
            }
        }
        return GetTop(OPND);


		/**************end************/
}

int main()
{
	char s[100];
	//用字符数组存储表达式，每个数组元素仅存一个字符
	while(1)
	{
		cin.getline(s,100);		//输入一行含空格的后缀表达式
		if(s[0]=='=') 
			break;				//当表达式只有一个"="时，输入结束
		SqStack OPND;
		InitStack(OPND);		//初始化数字栈
		cout<<fixed<<setprecision(2)<<EvaluateExpression(OPND,s)<<fixed<<setprecision(2)<<endl;
	}
	return 0;
}

第6关：基于栈的可操作判断

任务描述

本关任务：假设I和O分别代表入栈和出栈操作。栈的始态和终态均为空。入栈和出栈的操作序列可以表示为仅由I和O组成的序列，称可操作的序列为合法序列，否则称为非法序列。请设计一个算法，判断所给的操作序列是否合法。若合法输出“true”，反之输出“false”。

编程要求

输入

多组数据，每组数据一行，对应一个后缀算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。

输出

多组数据，每组数据为一行长度不定的操作序列A。当A为“0”时，输入结束。

测试说明

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

测试输入： IOIOIO IIOOOO 0

预期输出： TRUE FALSE

#include <iostream>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{
    char *base;
	char *top;
	int stacksize;
}SqStack;
int InitStack(SqStack &S)
{//初始化栈
	S.base=new char[MAXSIZE];
	if(!S.base) return OVERFLOW;
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
int Push(SqStack &S)
{//入栈
	S.top++;
	return OK;
}
int Pop(SqStack &S)
{//出栈
	S.top--;
	return OK;
}
int IsEmpty(SqStack S)
{//判断栈是否为空，空返回1，否则返回0
	return S.top==S.base;
}
bool Judge(char a[],SqStack &S)
{//栈的可操作判断
	/**************begin************/
     int i = 0;
   //写循环前先思考是否知道运行次数
   while(a[i] != '\0'){ //'\0' 表示空字符(null字符)
    if(a[i] == 'I'){
        if(S.top - S.base == S.stacksize) return false;
        Push(S);
    }else if(a[i] == 'O'){
        if(S.top == S.base) return false;
        Pop(S);
    }
    i++;
   }
   return IsEmpty(S);

	/**************end************/
}
int main()
{
    char a[100];
    while(cin>>a)
    {
        if(a[0]=='0') break;
        SqStack op;
        InitStack(op);
        if(Judge(a,op)) cout<<"TRUE"<<endl;
        else cout<<"FALSE"<<endl;
    }
    return 0;
}

luv.uv
关注
  • 21
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
编程题实训-栈
Junds0的博客
04-04 634
任务描述 本关任务：输入一个中缀算术表达式，求解表达式的值。运算符包括+、-、*、/、(、)、=，参加运算的数为double类型且为正数。（要求：直接针对中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可。）编程要求 输入 多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。参加运算的数为double类型。输出 对于每组数据输出一行，为表达式的运算结果。输出保留两位小数。 第2关：双栈的基本操作 任务描述 本关任务：将编号为
编程题实训-实验2-基于栈的算术表达式求值算法(北京林业大学)
Junds0的博客
10-16 1392
任务描述 本关任务：输入一个中缀算术表达式，求解表达式的值。运算符包括+、-、*、/、(、)、=，参加运算的数为double类型且为正数。（要求：直接针对中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可。） 第2关：中缀表达式转化为后缀表达式 任务描述 本关任务：输入一个中缀算术表达式，将其转换为后缀表达式。运算符包括+、-、*、/、(、)、=，参加运算的为小于10的自然数。（只考虑二元运算即可） 第3关：基于栈的后缀算术表达式求值 任务描述 本关任务：从键盘上输入一个后缀表
【数据结构】--栈的实现和多种例题
m0_74044018的博客
04-24 984
数据结构栈的概念，栈的实现，栈的几道经典面试题的详细讲解！
【 第4关：入栈和出栈的基本操作】【编程题实训-栈】【头歌】【bjfu-243】
Tommy_Nike的博客
10-29 6249
【头歌】【编程题实训-栈】【 第4关：入栈和出栈的基本操作】【bjfu-243】
北华航天工业学院实训--手机信息管理系统.zip
07-17
实训的目标可能是为了让学生深入理解数据结构的实际应用，包括但不限于链表、数组、树、图、队列、栈等基础结构。通过构建手机信息管理系统，学生们可能需要考虑如何设计合理的数据结构来存储手机型号、用户信息、...
招聘数据分析系统-课程实训-源代码
07-29
本实训项目“招聘数据分析系统”旨在通过Python、JavaScript、Echarts和MySQL等技术，帮助用户实现对招聘数据的深度挖掘与高效展示，从而提升招聘效率和质量。 一、系统架构 1. 前端技术栈：JavaScript作为主要的...
编程题实训-栈的基本操作
Junds0的博客
03-28 260
第一行为一个整数m，表示数组V的大小，第二行为四个整数e0、e1、d0、d1，e0和e1分别代表压入0号栈和1号栈的整数序列E0和E1的长度（依次连续入栈，中间没有出栈的情况），d0和d1分别代表从0号栈和1号栈弹出的序列的长度（依次连续出栈，中间没有入栈的情况）。当将一个非负十进制整数N转换为八进制数时，在计算过程中，把N与8求余得到的八进制数的各位依次进栈，计算完毕后将栈中的八进制数依次出栈输出，输出结果就是待求得的八进制数。多组数据，每组数据一行，对应一个后缀算术表达式，每个表达式均以“=”结尾。
头歌实践-编程题实训-栈的基本操作
UNUN549的博客
04-14 321
本关任务：输入一个整数序列a1,a2,a3...,an。当ai不等于-1时将ai进栈；当ai=-1时，输出栈顶元素并将其出栈。对于每一组数据输出若干行。每行为相应的出栈元素。当出栈异常时，输出“POP ERROR”并结束本组数据的输出。多组数据，每组数据有两行，第一行为序列的长度n，第二行为n个整数，整数之间用空格分隔。当n=0时输入结束。
【 第1关：基于栈的中缀算术表达式求值】【编程题实训-栈】【头歌】【bjfu-240】
Tommy_Nike的博客
10-29 7118
【头歌】【编程题实训-栈】【 第1关：基于栈的中缀算术表达式求值】【bjfu-240】
BJFU_数据结构习题_241双栈的基本操作
雪地行进
10-26 3164
241双栈的基本操作 描述 将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空；当第1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长（见下图）。试编写双栈初始化，判断栈空、栈满、进栈和出栈算法的函数。函数调用次序依次为：进栈、栈满的判断、出栈、栈空的判断。 双栈数据结构的定义如下： typedef ...
数据结构（五）----树（含堆）
weixin_73579966的博客
09-04 1014
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的.1.最上面的称为根结点，它没有前驱结点。2.除了根结点，其余结点被分成多个互不相交的集合，其中每个集合又是一棵子树，这些子树的根节点只有一个前驱，可以有0或多个后继3.树是递归定义的。一棵树：子树不能相交总的来说，二叉树的主要难点在于链式二叉树，而其中最重要的思想在于——递归，把大事化为一个重复递归的小事，而贯穿其中的方法是：画图。
数据结构经典排序之归并排序（超详细！！）
2301_79381549的博客
09-02 740
（Merge Sort）是一种分治策略的排序算法， 其基本思想是将待排序的序列划分为若干个子序列，每个子序列是一个有序的序列。在合并过程中，通过比较两个子数组的首元素，选择较小的元素放入新的数组中，然后移动下标，直到一个数组为空。递归进行排序并合并：对子序列递归地应用归并排序算法，然后将已排序的子序列合并成一个有序的序列，这是归并排序算法的核心步骤。从最底层的只包含一个元素的子数组开始，逐步向上层合并，每次合并都将两个有序数组合并成一个更大的有序数组。合并 [1] 和 [3]，得到 [1, 3]
数据结构----树
2301_77841194的博客
09-07 705
1、树(Tree)是n(n≥0)个结点的有限集。n=O时称为空树。在任意一棵非空树中:(1）有且仅有一个特定的称为根(Root)的结点;(2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1、T2、……、Tm,其中每一个集合本身又是一棵树,并且称为根的子树(SubTree)2、树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度(Degree)。度为0的结点称为叶结点（Leaf）或终端结点;度不为0的结点称为非终端结点或分支结点。
数据结构（六）----排序
weixin_73579966的博客
09-07 417
上面这三个是比较基础的排序算法，通常归在一起比较，从性能上来说，插入>冒泡>选择（诶嘿冒泡居然还不是倒数第一）下面将要介绍的则是一些改进的、有技术含量的排序了完结撒花！！！相信如果你掌握了本讲的所有排序算法并且能熟练手撕出来，你绝对是面试中的佼佼者1。
Java-数据结构-栈和队列-Stack和Queue (oﾟ▽ﾟ)o
最新发布
2303_80388948的博客
09-07 471
栈：是一种特殊的线性表，其 只允需在固定的一端进行插入和删除操作。 进行插入和删除的一端叫做栈顶，另一端叫做栈底。并且要遵循 先进后出 的规则。 队列：是一种只允许一端进行插入元素，在另一端进行删除元素的特殊的线性表。 队列具有 先进先出 的性质：进行插入的一端叫做队尾，进行删除的一端叫做队头。也就是队尾进，队头出。
数据结构——单链表实现和注释浅解
hedhjd的博客
09-07 133
【代码】数据结构——单链表实现和注释浅解。
Python面向对象编程实训
12-25
面向对象编程是一种编程范式，它将数据和操作封装在对象中，通过定义类和创建对象来实现。在Python中，我们可以使用类来创建自定义的数据类型，并在类中定义方法来操作这些数据。 下面是一个示例，展示了如何使用面向对象编程来实现栈这种数据结构： ```python class Stack: def __init__(self): self.stack = [] def is_empty(self): return len(self.stack) == 0 def is_full(self): # 假设栈的最大容量为100 return len(self.stack) == 100 def push(self, item): if not self.is_full(): self.stack.append(item) else: print("Stack is full!") def pop(self): if not self.is_empty(): return self.stack.pop() else: print("Stack is empty!") # 创建一个栈对象 stack = Stack() # 入栈操作 stack.push(1) stack.push(2) stack.push(3) # 出栈操作 print(stack.pop()) # 输出：3 print(stack.pop()) # 输出：2 print(stack.pop()) # 输出：1 ``` 在上面的示例中，我们定义了一个名为Stack的类，它具有入栈（push）、出栈（pop）、判栈空（is_empty）和判栈满（is_full）的操作。通过创建Stack类的对象，我们可以使用这些操作来操作栈的数据。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值