【数据结构】实验五：栈

最新推荐文章于 2024-07-23 12:24:57 发布
最新推荐文章于 2024-07-23 12:24:57 发布
阅读量1k 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65787507/article/details/131967871
版权

实验五  栈

一、实验目的与要求

1）熟悉栈的类型定义和基本操作；

2）灵活应用栈解决具体应用问题。

二、实验内容

1、判断回文数，回文是指正读反读均相同的字符序列，如“1221”和“12321”均是回文，但“1234”不是回文。请写一个算法判定给定的字符向量是否为回文。(提示：将一半字符入栈)

2、给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串s ，判断字符串是否有效。有效字符串需满足：

左括号必须用相同类型的右括号闭合。

左括号必须以正确的顺序闭合。

示列："()"和"()[]{}"都是合法的括号序列，但"( ]"和"( [ )]"不合法。

3、在某程序中，有两个栈共享一个一维数组空间SPACE[N]，SPACE[0]、SPACE[N-1] 分别是两个栈的栈底。(扩展选作)

  （1）对栈1、栈2，试分别写出（元素x）入栈的主要语句和出栈的主要语句。

  （2）对栈1、栈2，试分别写出栈满、栈空的条件。

三、实验结果

1）请将调试通过的源代码粘贴在下面。（代码注意书写规范、主要模块要有功能注释）

实验1代码：

#include <iostream>
#include <cstring>
using namespace std;
typedef struct{
	char data[1000];
	int top;
}Stack;

//初始化栈 
void Init_stack(Stack *s){
	s->top=-1;
}

//元素入栈 
void Push_stack(Stack *s,char x){
	s->top=s->top+1;
	s->data[s->top]=x;
}

//元素出栈 
void Pop_stack(Stack *s,char *x){
	*x=s->data[s->top];
	s->top=s->top-1;
}
 
int main(){
	char data[1000],x;
	int i;
	Stack s;
	
	//初始化测试栈 
	Init_stack(&s);
	cin>>data;
	
	//输入的字符串长度 
	int len=strlen(data);
	
	//输入的字符串入栈 
	for(i=0;i<len;i++){
		Push_stack(&s,data[i]);
	}
	
	//首尾对比，判断回文数 
	for(i=0;i<len;i++){
		Pop_stack(&s,&x);
		if(data[i]!=x){
			cout<<"不是回文数"<<endl;
			return 0;
		}
	}
	cout<<"是回文数"<<endl;
	return 0;
}

实验1结果展示：

 

 

 

 实验2代码：

#include <iostream>
#include <cstring>
using namespace std;

typedef struct{
	char data[1000];//元素 
	int top;//顶指针 
}Stack;

//初始化栈 
void Init_stack(Stack *s){
	s->top=-1;
}

//元素入栈 
void Push_stack(Stack *s,char *x){
	s->top=s->top+1;
	s->data[s->top]=*x;
}

//元素出栈 
void Pop_stack(Stack *s,char *x){
	*x=s->data[s->top];
	s->top=s->top-1;
}

int main(){
	char str[1000];
	Stack s;
	Init_stack(&s);
	cout<<"Please input your string：";
	cin>>str;
	int len=strlen(str),i=0;//len为str的长度 
	//cout<<len;
	
	//如果长度为奇数，一定缺少括号 
	if(len%2!=0){
		cout<<"Wrong string!"<<endl;
		return 0;
	}
	
	//长度为偶数，分类讨论 
	for(i=0;i<len;i++){
		//[]情况 
		if(str[i]=='['){
			Push_stack(&s,&str[i]);
			if(str[i+1]==']'){
				Pop_stack(&s,&str[i]);
				continue;
			}
			else{
				cout<<"Wrong string!"<<endl;
				return 0;
			}
		}
		//()情况 
		if(str[i]=='('){
			Push_stack(&s,&str[i]);
			if(str[i+1]==')'){
				Pop_stack(&s,&str[i]);
				continue;
			}
			else{
				cout<<"Wrong string!"<<endl;
				return 0;
			}
		}
		//{}情况 
		if(str[i]=='{'){
			Push_stack(&s,&str[i]);
			if(str[i+1]=='}'){
				Pop_stack(&s,&str[i]);
				continue;
			}
			else{
				cout<<"Wrong string!"<<endl;
				return 0;
			}
		}
	}
	cout<<"Right string!"<<endl; 
	return 0;
}

实验2结果展示：

 

 

 

 

 实验3代码：

#include <cstdio>
#define MaxSize 10 //栈的容量 
#define ElemType int
#include <iostream>
using namespace std;			

typedef struct {
	ElemType data[MaxSize];		
	int top1;//1号栈栈顶指针
	int top2;//2号栈栈顶指针
}ShStack;

//初始化共享栈
void InitShStack(ShStack& S) {
	S.top1 = -1;//初始化1号栈栈顶指针
	S.top2 = MaxSize;//初始化2号栈栈顶指针
}

//1号栈判空
bool Stack1Empty(ShStack S) {
	return (S.top1 == -1);
}

//2号栈判空
bool Stack2Empty(ShStack S) {
	return (S.top2 == MaxSize);
}

//1号栈入栈操作：新元素入栈(先存再加)
bool Push1(ShStack& S, ElemType x) {
	if (S.top1+1 == S.top2){
		return false;//栈满，报错
	}
	S.data[++S.top1] = x;
	return true;
}

//2号栈入栈操作：新元素入栈(先存再加)
bool Push2(ShStack& S, ElemType x) {
	if (S.top1+1 == S.top2){
		return false;//栈满，报错
	}
	S.data[--S.top2] = x;
	return true;
}

//1号栈出栈操作：栈顶元素出栈
bool Pop1(ShStack& S, ElemType& x) {
	if (S.top1 == -1){
		return false;//1号栈栈空，报错
	}
	x = S.data[S.top1--];	
	return true;
}

//2号栈出栈操作：栈顶元素出栈
bool Pop2(ShStack& S, ElemType& x) {
	if (S.top2 == MaxSize){
		return false;//2号栈栈空，报错
	}
	x = S.data[S.top2++];
	return true;
}

//1号栈读取栈顶元素操作
bool GetTop1(ShStack S, ElemType& x) {
	if (S.top1 == -1){
		return false;//1号栈栈空，报错
	}
	x = S.data[S.top1];
	return true;
}

//2号栈读取栈顶元素操作
bool GetTop2(ShStack S, ElemType& x) {
	if (S.top2 == MaxSize){
		return false;//2号栈栈空，报错
	}
	x = S.data[S.top2];
	return true;
}

int main() {
	//声明一个共享栈
	ShStack S;		

	//初始化共享栈
	InitShStack(S);

	//1号栈-判空
	if(Stack1Empty(S)){
		printf("当前1号栈空！\n");
	}
	else{
		printf("当前1号栈非空！\n");
	}
	
	//1号栈-入栈操作
	ElemType e1;
	printf("请输入1号栈入栈元素的值：");
	scanf("%d", &e1);
	if(Push1(S, e1)){
		printf("1号栈新元素入栈成功！\n");
	}
	else{
		printf("共享栈已满,1号栈新元素入栈失败！\n");
	}

	//1号栈-读取栈顶元素
	ElemType e2 = -1;
	if(GetTop1(S, e2)){
		printf("1号栈读取栈顶元素成功，当前栈顶元素值为：%d\n", e2);
	}
	else{
		printf("1号栈已空，读取栈顶元素失败！\n");
	}

	//1号栈-出栈操作
	ElemType e3 = -1;
	if(Pop1(S, e3)){
		printf("1号栈栈顶元素出栈成功，出栈元素值为：%d\n", e3);
	}
	else{
		printf("1号栈已空，栈顶元素出栈失败！\n");
	}

	//1号栈-读取栈顶元素
	ElemType e4 = -1;
	if (GetTop1(S, e4))
		printf("1号栈读取栈顶元素成功，当前栈顶元素值为：%d\n", e4);
	else
		printf("1号栈已空，读取栈顶元素失败！\n");
		
	cout<<endl;

	//2号栈-判空
	if (Stack2Empty(S)){
		printf("当前2号栈空！\n");
	}
	else{
		printf("当前2号栈非空！\n");
	}

	//2号栈-入栈操作
	ElemType e21;
	printf("请输入2号栈入栈元素的值：");
	scanf("%d", &e21);
	if (Push2(S, e21)){
		printf("2号栈新元素入栈成功！\n");
	}
	else{
		printf("共享栈已满,2号栈新元素入栈失败！\n");
	}

	//2号栈-读取栈顶元素
	ElemType e22 = -1;
	if (GetTop2(S, e22)){
		printf("2号栈读取栈顶元素成功，当前栈顶元素值为：%d\n", e22);
	}
	else{
		printf("2号栈已空，读取栈顶元素失败！\n");
	}
	
	//2号栈-出栈操作
	ElemType e23 = -1;
	if (Pop2(S, e23)){
		printf("2号栈栈顶元素出栈成功，出栈元素值为：%d\n", e23);
	}
	else{
		printf("2号栈已空，栈顶元素出栈失败！\n");
	}

	//2号栈-读取栈顶元素
	ElemType e24 = -1;
	if (GetTop2(S, e24)){
		printf("2号栈读取栈顶元素成功，当前栈顶元素值为：%d\n", e24);
	}
	else{
		printf("2号栈已空，读取栈顶元素失败！\n");
	}
		
	return 0;
}

实验3结果展示：

 

2）请分析你程序中每个功能模块的算法时间复杂度。

实验1：

单元素出栈只需要锁定顶层的元素即可。所以，时间复杂度为O(1)。

单元素入栈只需要对顶层进行元素覆盖即可。所以，时间复杂度为O(1)。

假设字符串长度为len，那么多元素入栈需要执行len次。所以，时间复杂度为O(n)。

本段代码通过对入栈后的字符串反向出栈进行判断，即出栈的第一个元素是原来字符串的最后一个元素。我们可以令出栈的第一个元素与原字符串的第一个元素进行对比，来判断该字符串对应的数字是否为回文数。所以，时间复杂度为O(n)。

实验2：

出栈、入栈等操作沿用实验1的结果，这里不再赘述。

当输入的符号字符串长度为奇数的时候，一定有一个括号落单，即一定不可能为合法的输入。符号字符串的长度为偶数是必要不充分条件，因此直接否定奇数长度可减少算力。所以，时间复杂度为O(1)。

本段算法通过循环先对当前的字符进行判断，再对下一个邻近的字符进行判断，即判断相邻两个括号是否为合法输入。整个过程需要对字符串每一个位置的字符进行判断。所以，时间复杂度为O(n)。

实验3：

判断栈是否为空栈，只需要判断顶指针是否处于-1位置。所以，时间复杂度为O(1)。

新元素入栈的时候，先要判断共享栈是否已满。如果共享栈非满，那么在下一个位置插入一个元素，顶指针同时移动到该位置。所以，时间复杂度为O(1)。

新元素出栈的时候，先要判断共享栈是否已空。如果共享栈非空，那么在当前位置弹出一个元素，顶指针同时移动到前一个位置。所以，时间复杂度为O(1)。

查看共享栈的两个栈顶元素时，只需要在保证两个栈非空的情况下，对顶指针所指向的元素进行查看。所以，时间复杂度为O(1)。

其他：

#include<iostream>
#include<cstring>
#define STACK_INIT_SIZE 100
#define STACK_INCREMENT 10
using namespace std;
 
typedef struct SqStack {
 char *elem;
 int top;
 int stacksize;
}SqStack;
 
//初始化栈，容量是事先定义好的，定义初始的top标号为-1.
void InitStack(SqStack& S)
{
 S.elem = new char[STACK_INIT_SIZE];
 if (!S.elem)
  cout << "Overflow!" << endl;
 S.top = -1;
 S.stacksize = STACK_INIT_SIZE;
}
 
//该函数用来释放栈的空间
void DestroyStack(SqStack& S)
{
 delete[]S.elem;
 S.top = -1;
 S.stacksize = 0;
}
 
//若栈已满，该函数用来增加栈的空间
void increment(SqStack& S)
{
 char *newstack = new char[S.stacksize + STACK_INCREMENT];
 if (!newstack)
  cout << "Overflow!" << endl;
 for (int i = 0; i <= S.top; i++)
 {
  newstack[i] = S.elem[i];
 }
 delete[]S.elem;
 S.elem = newstack;
 S.stacksize += STACK_INCREMENT;
}
 
//该函数用来往栈里面增添元素，因为是入栈，所以栈顶元素的位置数加一，该元素成为新的栈顶元素
void Push(SqStack& S, char e)
{
 if (S.top == S.stacksize - 1)
  increment(S);
 S.elem[++S.top] = e;
}
 
//该元素用来返回栈顶元素的值
char GetTopStack(SqStack& S)
{
 if (S.top == -1)
  cout << "Empty!" << endl;
 return S.elem[S.top];
}
 
//该函数用来将元素出栈
void Pop(SqStack& S)
{
 if (S.top == -1)
  cout << "Empty!" << endl;
 S.top--;
}
 
//主函数：将字符串的长度len对2取模记为mid，将前mid个字符入栈。若该字符串回文：先给标志赋值为0，如果len为偶数，则第mid+1个元素应和栈顶元素相同，如果不同就直接退出循环，将标志的值改为1；相同就将元素出栈，判断下一个字符和栈顶元素是否相等，以此类推。如果len为奇数，则最中间的元素和其它元素都不同，跳过这个元素继续向下判断。最后通过标志的值判断该字符串是否回文：如果标志的值被修改，说明对称的两元素不相同，则字符串不回文。
int main()
{
 SqStack s;
 InitStack(s);
 char str[1000];
 cin >> str;
 int len = strlen(str);
 int mid = len / 2;
 int i, flag = 0;
 for (i = 0; i < mid; i++)
 {
  Push(s, str[i]);
 }
 if (len % 2 == 1)
  i++;
 while (i<len)
 {
  if (GetTopStack(s) != str[i])
  {
   flag = 1;
   break;
  }
  i++;
  Pop(s);
 }
 if (flag)
 {
  cout << "该字符向量不是回文！" << endl;
 }
 else
 {
  cout << "该字符向量是回文！" << endl;
 }
 return 0;
}

#include<iostream>
#include<cstring>
#define STACK_INIT_SIZE 100
#define STACK_INCREMENT 10
using namespace std;
 
typedef struct SqStack {
 char* elem;
 int top;
 int stacksize;
}SqStack;
 
//初始化栈，容量是事先定义好的，定义初始的top标号为-1.
void InitStack(SqStack& S)
{
 S.elem = new char[STACK_INIT_SIZE];
 if (!S.elem)
  cout << "Overflow!" << endl;
 S.top = -1;
 S.stacksize = STACK_INIT_SIZE;
}
 
//该函数用来释放栈的空间
void DestroyStack(SqStack& S)
{
 delete[]S.elem;
 S.top = -1;
 S.stacksize = 0;
}
 
//若栈已满，该函数用来增加栈的空间
void increment(SqStack& S)
{
 char* newstack = new char[S.stacksize + STACK_INCREMENT];
 if (!newstack)
  cout << "Overflow!" << endl;
 for (int i = 0; i <= S.top; i++)
 {
  newstack[i] = S.elem[i];
 }
 delete[]S.elem;
 S.elem = newstack;
 S.stacksize += STACK_INCREMENT;
}
 
//该函数用来往栈里面增添元素，因为是入栈，所以栈顶元素的位置数加一，该元素成为新的栈顶元素
void Push(SqStack& S, char e)
{
 if (S.top == S.stacksize - 1)
  increment(S);
 S.elem[++S.top] = e;
}
 
//该元素用来返回栈顶元素的值
char GetTopStack(SqStack& S)
{
 if (S.top == -1)
  cout << "Empty!" << endl;
 return S.elem[S.top];
}
 
//该函数用来将元素出栈
void Pop(SqStack& S)
{
 if (S.top == -1)
  cout << "Empty!" << endl;
 S.top--;
}
 
//主函数：输入字符串，向后遍历，如果元素是左括号则将左括号入栈，如果元素是右括号，则将左括号弹出栈顶，这样可以继续判断下一个左括号是否和右括号匹配。一旦右括号和左括号匹配不成功，那么修改标志表示括号匹配失败。其中，需要一开始就将‘#’压入栈，如果最后字符串遍历完了（也就是左括号都被消解完了）栈顶元素是‘#’，说明左括号和右括号匹配上不多不少刚刚好。
int main()
{
 SqStack s;
 int flag = 1;
 InitStack(s);
 Push(s, '#');
 char str[1000];
 cin >> str;
 int len = strlen(str);
 for (int i = 0; i < len; i++)
 {
  if (str[i] == '(' || str[i] == '[' || str[i] == '{')
   Push(s, str[i]);
  else
  {
   if (str[i] == ')')
   {
    if (GetTopStack(s) != '(')
    {
     flag = 0;
     break;
    }
    else
     Pop(s);
   }
   else if (str[i] == ']')
   {
    if (GetTopStack(s) != '[')
    {
     flag = 0;
     break;
    }
    else
     Pop(s);
   }
   else if (str[i] == '}')
   {
    if (GetTopStack(s) != '{')
    {
     flag = 0;
     break;
    }
    else
     Pop(s);
   }
  }
 }
 if (GetTopStack(s) != '#')
  flag = 0;
 if (flag)
  cout << "括号匹配成功！" << endl;
 else
  cout << "括号匹配失败！" << endl;
 return 0;
}

设top1和top2分别为栈1和2的栈顶元素的位置。

(1) 入栈主要语句

栈1的入栈语句：

if(top2-top1==1)

{

cout<<“栈满”<<endl;

exit(0);

}

SPACE[++top1]=x; //设x为入栈元素。

栈2的入栈语句：

if(top2-top1==1)

{

cout<<“栈满”<<endl;

exit(0);

}

SPACE[--top2]=x;

出栈主要语句

栈1的出栈语句:

if(top1==-1)

{

cout<<“栈空”<<endl;

exit(0);

}

top1--;

return(SPACE[top1+1]); //返回出栈元素。

栈2的出栈语句:

if(top2==N)

{

cout<<“栈空”<<endl;

exit(0);

}

top2++;

return(SPACE[top2-1]);

  1. 栈满条件:top2-top1=1

栈空条件:top1=-1并且top2=N //top1=-1为左栈空,top2=N为右栈空

MorleyOlsen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
栈——实验及提升训练
Junds0的博客
05-25 1109
第1关：栈与递归函数 #include <stdlib.h> #include <stdio.h> #include<string.h> #define YES 1 #define NO 0 typedef int status; // 自己定义需要的栈结构，及栈基本操作函数，假设操作数都是整数 typedef struct stack { char str[100][50]; int MAX; int top; }*Stack; Stack
栈的基本操作，以及判断是否是回文
m0_68537868的博客
04-09 250
#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #include<stdlib.h> #include<stdio.h> #include<malloc.h> #include"ydy.h" #include<iostream> using namespace std; typedef int Elemtype; typedef int Status; typedef struct { Elemt.
数据结构实验（五）
Capricorn_wow的博客
11-09 1773
1.实验题目 针对某个集体中人名设计一个哈希表，使得平均查找长度不超过 R，并完成相应的建表和查表程序。假设人名为中国人姓名的汉语拼音形式。待填入哈希表的人名共有 30 个，取平均查找 长度的上限为 哈希函数用除留余数法构造，用线性探测再散列法或链地址法处理冲突。 2.需求分析 需将姓名拼音转化为数字才能比较 哈希表冲突后的探测使用线性探测法 采用数组形式进行存储 3.概要设计 存储数据包括 拼音 地址 查找次数，查找长度 哈希表的存储过程 根据关键字查找 函数的调用 ...
数据结构实验5 数据结构实验5
09-16
数据结构实验5 数据结构实验5 数据结构实验5 数据结构实验5 数据结构实验5
数据结构实验题（入栈，出栈）
05-27
数据结构实验报告 1）熟练掌握二叉树的二叉链表表示及前序创建算法与实现； 2）熟练掌握二叉树的前序、中序和后序递归遍历算法与实现； 3）掌握中序遍历线索二叉树的基本算法与实现 4）掌握中序遍历线索化二叉树的算法与实现； 5）按照实验题目要求独立完成实验内容（提交程序清单及相关实验数据与运行结果）； 6）认真书写实验报告,并按时提交。
数据结构实验报告（四）——栈和字符串
future_dreaming的博客
01-10 1480
通过本次实验，我们学会了栈的结构及基本运算的实现方法、用栈实现表达式计算的基本技术，掌握了应用栈进行问题求解的基本方法，理解了串的有关概念和运算实现，掌握了快速模式匹配等串的典型算法，这次的实验涉及到的知识点有点多，最开始有点难理解，但是通过不断的练习，最终还是能够准确地理解这些算法。创建字符串、再实现字符串的系列操作，注意字符串的长度。先建立一个空队列，进行判空、入队、出队、打印等操作。1、掌握栈的结构及基本运算的实现方法。2、掌握用栈实现表达式计算的基本技术。3、掌握应用栈进行问题求解的基本方法。
数据结构（C语言）- 栈子系统（实验）
czh2637750821的博客
01-22 3920
栈子系统1.实验内容2.实验内容3.源代码 1.实验内容 （1）掌握栈的特点及其存储方式。 （2）用链式存储结构实现一个栈。 （3）掌握栈的初始化、进栈、出栈和显示栈顶元素等基本操作。 （4）了解进制转换及表达式转换并求值的算法。 2.实验内容 （1）定义一个字符类型的单链栈。 （2）编写出实现进栈、出栈、显示栈顶元素 （3）编写一个求进制转换的算法。 （4）编写一个将中缀表达式转换成后缀表达式的函数，在设计一个用该后缀表达式求值的函数。 （5）设计如下选择式菜单，以选择菜单方式操作。将上述各种算法实现。
数据结构实验3：栈子系统.doc
12-03
数据结构实验3：栈子系统.doc 数据结构实验3：栈子系统.doc是关于数据结构实验的第三个实验，主要介绍栈的特点、描述方法和实现方式。下面是该实验的详细知识点： 栈的特点 栈是一种特殊的线性表，它具有Last-In-...
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
数据结构实验1.5：一元多项式的相加和相乘.doc
10-29
这可能需要额外的数据结构（如栈或队列）来存储多项式的中间状态，以便在需要时恢复。 在实际编程中，还需要考虑错误处理，如无效输入、内存分配失败等情况。同时，为了提高效率，可以考虑使用优化算法，如快速...
数据结构 实验五
jbb8215188的博客
10-17 99
【代码】数据结构 实验五。
栈的实验
weixin_41842123的博客
04-26 411
顺序栈头文件：#ifndefseqstack_H#defineseqstack_Hconstint stackSize=10;template&lt;classdatatype&gt;classseqstack{        public:                seqstack();                ~seqstack(){}                void Pu...
栈的练习
heinara的博客
05-04 368
一、实验目的及要求 1、6个乱序的字母，判断是否可以通过a b c d e f的入栈出栈操作，得到乱序字母序列，若能则输出入栈出栈字母操作的顺序。输入要求：输入一串含abcdef的乱序字母 2、四则运算，通过栈实现简单的四则运算，输入要求：例#5*(4-2)-3*6+8# 输出要求：输出运算结果。 3、括号的匹配：输入要求：一串含有( )< >{ }[ ]的序列，判断是否括号是否能够正...
数据结构实验报告
WingPassager的博客
03-11 2460
数据结构与算法操作实验三(栈的操作) 一、实验目的 1．掌握栈的存储结构的表示和实现方法。 2．掌握栈的入栈和出栈等基本操作算法实现。 3．了解栈在解决实际问题中的简单应用。 二、实验内容 1．建立顺序栈，并在顺序栈上实现入栈和出栈操作（验证性内容）。 2．建立链栈，并在链栈上实现入栈和出栈操作（设计性内容）。 3．实现汉诺（Hanoi）塔求解问题（应用性设计内容）。 三、实验的软硬件环境要求 硬件环境要求： PC机（单机） 使用的软件名称、版本号以及模块： Windows环境下的VC++等。 四、知识准备
链式线性表——实验及提升训练
小蒋的博客
10-14 737
数据结构实验一作业
【数据结构C/C++】顺序栈和链栈详解(附代码)
热门推荐
Zhangsama1的博客
08-11 1万+
文章目录前言一、栈的顺序结构及其实现1：顺序栈概念理解2：入栈(压栈)实现方法3：出栈(弹栈)及其实现方法4：顺序栈输出其数据5：主函数二、栈的链式存储结构1.链栈概念理解2.初始化链栈3.链栈元素入栈4.链表元素出栈5.显示链栈元素6.主函数三、链栈与顺序栈优缺点对比 前言 栈是限定仅在表尾进行插入和删除操作的线性表。 我们把允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)，不含任何数据元素的栈称为空栈。栈又称为后进先出(Last In First Out)的线性表，简称LIFO
7-1 判断回文字符串
weixin_46016713的博客
11-26 4970
7-1 判断回文字符串 (10分) 输入一个字符串，判断该字符串是否为回文。回文就是字符串中心对称，从左向右读和从右向左读的内容是一样的。 输入格式: 输入在一行中给出一个不超过80个字符长度的、以回车结束的非空字符串。 输出格式： 输出在第1行中输出字符串。如果它是回文字符串，在第2行中输出Yes，否则输出No。 输入样例1： level 输出样例1： level Yes 输入样例2： 1 + 2 = 2 + 1 = 输出样例2： 1 + 2 = 2 + 1 = No 代码展示： #inc
数据结构——二叉树性质
最新发布
鲸落博客
07-23 286
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
数据结构实验报告：栈和队列的实现
实验结果的分析表明，栈和队列是两种基本的数据结构，它们广泛应用于各种软件系统中。 九、结论 本文详细介绍了栈和队列的定义、特点、操作特性和实现方法。栈和队列是两种基本的数据结构，它们广泛应用于各种软件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MorleyOlsen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值