顺序栈，共享栈和结构体中“.”与“-＞”的区别

最新推荐文章于 2023-09-10 11:11:34 发布
最新推荐文章于 2023-09-10 11:11:34 发布
阅读量305 收藏 4
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75220252/article/details/131027122
版权

1.top指向栈顶元素，令S.top = -1。

(1)初始化

//初始化
void InitStack(SqStack *S)
{
	S->top = -1;
}

（2）判断栈是否为空

//判断栈是否为空
bool StackEmpty(SqStack *S)
{
	if(S->top == -1)
		return true;
	else
		return false;
}

（3）进栈

//进栈
bool Push(SqStack *S,int x)
{
	if(S->top == Maxsize-1)//栈满，报错
		return false;
	S->data[++S->top] = x;//指针先加1，再入栈
	return true;
}

（4）出栈

//出栈
bool Pop(SqStack *S,int &x)
{
	if(S->top == -1)//栈空，报错
		return false;
	x = S->data[S->top--];//先出栈，指针再减1
	return true;
}

（5）读栈顶元素

//读栈顶元素
int GetTop(SqStack *S,int &x)
{
	if(S->top == -1)
		return 0;
	else
		{
		  x = S->data[S->top];
	     return x;
	    }
}

（6）遍历输出

//遍历输出
bool Traverse(SqStack *S)
{
  int i = S->top;
  if(StackEmpty(S))
  {
    printf("栈为空！");
	return false;
  }
  else
  {
	  while(i != -1)
	  {
	  printf("%d\n",S->data[i--]);
	  
	  }
	  return true;
  }
}

运行结果

2.栈顶指针初始化为S.top=0，即top指向栈中下一个可以插入元素的位置

（1）初始化

//初始化
void InitStack(SqStack *S)
{
	S->top = 0;//初始化
}

 （2）判断栈是否为空

//判断栈是否为空
bool StackEmpty(SqStack *S)
{
	if(S->top == 0)//当为0时栈为空
		return true;
	else
		return false;
}

（3）进栈

//进栈
bool Push(SqStack *S,int x)
{
	if(S->top == Maxsize+1)//栈满，报错
		return false;
	S->data[S->top++] = x;//先入栈，指针再加1，所以压栈10个元素之后指针为11
	return true;
}

（4）出栈

//出栈
bool Pop(SqStack *S,int &x)
{
	if(S->top == 0)//栈空，报错
		return false;
	x = S->data[--S->top];//指针先减1，再出栈，所以当栈中元素全部出栈之后指针为0
	return true;
}

（5）读栈顶元素

//读栈顶元素
int GetTop(SqStack *S,int &x)
{
	if(S->top == 0)
		return 0;
	else
		{
		  x = S->data[S->top];
	     return x;
	    }
}

运行结果

前两个对比，++S->top表示的是先加1然后再运行S->data[] ；S->top++表示的是先运行S->data[]然后S->top再加1.

3.共享栈

利用栈底元素相对位置不变的特性，可以让顺序栈共享一个一维数组空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延伸。两个栈的栈顶指针都是指向栈顶元素，假设top0=-1时为top0那边栈为空，top1=maxsize为top1那边栈为空；仅当两个指针相邻（top1-top0=1）时，判断栈满。top0先加1再赋值，top1先减1再赋值；相当于top0指向小的那边，top1指向栈大的那边

（1）初始化

void InitStack(SqStack &S)
{
	S.top0 = -1;
	S.top1 = maxsize;
}

（2）判断栈是否为空

bool StackEmpty(SqStack &S)
{
	if(S.top0 == -1 || S.top1 == maxsize)
		return true;
	else
		return false;
}

（3）进栈

bool Push(SqStack &S, int x,int y)
{
	if(S.top1 - S.top0 == 1)
		return false;
	else
	{
		S.data[++S.top0] = x;
		S.data[--S.top1] = y;
	}
	return true;
}

（4）出栈

bool Pop(SqStack &S,int &x,int &y)
{
	if(S.top0 != -1 || S.top1 != maxsize )
		return false;
	else
	{
		x = S.data[S.top0--];
		y = S.data[++S.top1];
	}
	return true;
}

（5）读栈顶元素

因为C++里面不可以同时返回两个值，所以可以通过结构体来达成，并且不要弄成指针类型，例如val->a这样是无法输出出去，会出错
return_X_Y Get(SqStack &S,int &x,int &y)
{
	 struct return_X_Y val;
	if(S.top0 != -1)
		val.a = S.data[S.top0];
	if(S.top1 != maxsize)
		val.b= S.data[S.top1];
	return val;
}

（6）遍历输出

void traverse(SqStack &S)
{
  if(S.top0 == -1 || S.top1 == maxsize)
	 { 
		 printf("栈为空！\n");
		 return;
     }
  if(S.top0 == -1)
	  printf("top0那边为空\n");
  if(S.top1 == maxsize)
	  printf("top1那边为空\n");
  int i = S.top0;
  int j = S.top1;
  printf("top0那边元素为：\n");
  while(i != -1)
  {
	  printf("%d\n",S.data[i--]);
  }
  printf("top1那边元素为：\n");
  while(j != maxsize)
  {
	  printf("%d\n",S.data[j++]);
  }
  return;
}

运行结果

结构体中“.”与“->”的区别

1、A->a表示A是指向结构体的指针

2、A.a表示A是结构体

3、A->a等效于(*A).a

4、A.B则A为对象或者结构体

5、A->B则A为指针，->是成员提取，A->B是提取A中的成员B，A只能是指向类、结构、联合的指针；

可以通过顺序栈和共享栈进行比较“.”与“->”的用法

顺序栈中使用的是"->"如果将其换成”.“,然后将S前的”*“换成"&",然后将main函数中的&去掉也会运行成功，以此来体验结构体中”.“与”->“的差别

全部代码

顺序表

//本次代码数据域以整数型为主
#include<stdio.h>

#define Maxsize 10
typedef struct 
{
  int data[Maxsize];
  int top;
}SqStack;
//函数说明
void InitStack(SqStack *S);//初始化
bool StackEmpty(SqStack *S);//判断栈是否为空
bool Push(SqStack *S,int x);//进栈
bool Pop(SqStack *S,int &x);//出栈
int GetTop(SqStack *S,int &x);//读取栈顶元素
bool Traverse(SqStack *S);//遍历输出
int main(void)
{
  SqStack S;
  int x;
  InitStack(&S);
  Push(&S,1);
  Push(&S,2);
  Push(&S,3);
  Push(&S,4);
  Push(&S,5);
  Push(&S,6);
  Push(&S,7);
  Push(&S,8);
  Push(&S,9);
  Push(&S,10);
  Traverse(&S);
  int val = GetTop(&S,x);
  printf("栈顶元素为：%d\n",val);
  Pop(&S,x);
  printf("出栈之后栈中元素为：\n");
  Traverse(&S);

  return 0;

}

/*//top指的是栈顶元素
//初始化
void InitStack(SqStack *S)
{
	S->top = -1;
}

//判断栈是否为空
bool StackEmpty(SqStack *S)
{
	if(S->top == -1)
		return true;
	else
		return false;
}

//进栈
bool Push(SqStack *S,int x)
{
	if(S->top == Maxsize-1)//栈满，报错
		return false;
	S->data[++S->top] = x;//指针先加1，再入栈
	return true;
}

//出栈
bool Pop(SqStack *S,int &x)
{
	if(S->top == -1)//栈空，报错
		return false;
	x = S->data[S->top--];//先出栈，指针再减1
	return true;
}

//读栈顶元素
int GetTop(SqStack *S,int &x)
{
	if(S->top == -1)
		return 0;
	else
		{
		  x = S->data[S->top];
	     return x;
	    }
}

//遍历输出
bool Traverse(SqStack *S)
{
  int i = S->top;
  if(StackEmpty(S))
  {
    printf("栈为空！");
	return false;
  }
  else
  {
	  while(i != -1)
	  {
	  printf("%d\n",S->data[i--]);
	  
	  }
	  return true;
  }
}
*/

//top指向栈顶元素的下一个位置
//初始化
void InitStack(SqStack *S)
{
	S->top = 0;//初始化
}

//判断栈是否为空
bool StackEmpty(SqStack *S)
{
	if(S->top == 0)//当为0时栈为空
		return true;
	else
		return false;
}

//进栈
bool Push(SqStack *S,int x)
{
	if(S->top == Maxsize+1)//栈满，报错
		return false;
	S->data[S->top++] = x;//先入栈，指针再加1，所以压栈10个元素之后指针为11
	return true;
}

//出栈
bool Pop(SqStack *S,int &x)
{
	if(S->top == 0)//栈空，报错
		return false;
	x = S->data[--S->top];//指针先减1，再出栈，所以当栈中元素全部出栈之后指针为0
	return true;
}

//读栈顶元素
int GetTop(SqStack *S,int &x)
{
	if(S->top == 0)
		return 0;
	else
		{
		  x = S->data[S->top];
	     return x;
	    }
}

//遍历输出
bool Traverse(SqStack *S)
{
  int i = S->top;
  if(StackEmpty(S))
  {
    printf("栈为空！");
	return false;
  }
  else
  {
	  while(i != 0)
	  {
	  printf("%d\n",S->data[--i]);
	  
	  }
	  return true;
  }
}

共享栈

#include<stdio.h>
#define maxsize 15
typedef struct
{
  int data[maxsize];
  int top0;
  int top1;
}SqStack;

struct return_X_Y
{
  int a;
  int b;
};

//函数说明
void InitStack(SqStack &S);
bool StackEmpty(SqStack &S);
bool Push(SqStack &S, int x,int y);
bool Pop(SqStack &S,int &x,int &y);
return_X_Y Get(SqStack &S,int &x,int &y);
void traverse(SqStack &S);
int main(void)
{
  SqStack S;
  int x,y;
  
  InitStack(S);
  Push(S,1,-1);
  Push(S,2,-2);
  Push(S,3,-3);
  Push(S,4,-4);
  Push(S,5,-5);
  Push(S,6,-6);
  Push(S,7,-7);
  traverse(S);
   struct return_X_Y pVal = Get(S,x,y);
  printf("top0,top1两边栈顶元素分别为：%d,%d\n",pVal.a,pVal.b);
  Pop(S,x,y);
  printf("删除元素之后栈中元素为：\n");
  traverse(S);
  return 0;
}

void InitStack(SqStack &S)
{
	S.top0 = -1;
	S.top1 = maxsize;
}

bool StackEmpty(SqStack &S)
{
	if(S.top0 == -1 || S.top1 == maxsize)
		return true;
	else
		return false;
}

bool Push(SqStack &S, int x,int y)
{
	if(S.top1 - S.top0 == 1)
		return false;
	else
	{
		S.data[++S.top0] = x;
		S.data[--S.top1] = y;
	}
	return true;
}

bool Pop(SqStack &S,int &x,int &y)
{
	if(S.top0 != -1 || S.top1 != maxsize )
		return false;
	else
	{
		x = S.data[S.top0--];
		y = S.data[++S.top1];
	}
	return true;
}


return_X_Y Get(SqStack &S,int &x,int &y)
{
	 struct return_X_Y val;
	if(S.top0 != -1)
		val.a = S.data[S.top0];
	if(S.top1 != maxsize)
		val.b= S.data[S.top1];
	return val;
}


void traverse(SqStack &S)
{
  if(S.top0 == -1 || S.top1 == maxsize)
	 { 
		 printf("栈为空！\n");
		 return;
     }
  if(S.top0 == -1)
	  printf("top0那边为空\n");
  if(S.top1 == maxsize)
	  printf("top1那边为空\n");
  int i = S.top0;
  int j = S.top1;
  printf("top0那边元素为：\n");
  while(i != -1)
  {
	  printf("%d\n",S.data[i--]);
  }
  printf("top1那边元素为：\n");
  while(j != maxsize)
  {
	  printf("%d\n",S.data[j++]);
  }
  return;
}

尘桥湖
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c代码-结构体组指针 (*p).number p->number （等价）
07-16
c代码-结构体组指针 (*p).number p->number （等价）
5.matlab结构体.zip
07-13
5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.matlab结构体.zip5.mat
C语言基础 --- 结构体中的.和-＞的区别与联系
wit_732的博客
09-12 2675
C语言基础 — 结构体中的.和->的区别与联系 1. 基本功能 这两种方式其实都是结构体成员运算符，两者都具有从左到右的结合性。不同的是： '.'是结构体引用成员变量的方式。 '->' 是结构体指针引用成员变量的方式。 2. 联系 那么既然有了’.‘这个符号，为什么还要再弄个’->‘符号呢？这不是很麻烦吗？然而，事实并非如此，’->'恰巧是为了我们更好的使用结构体这一有利的工具。请看下面这个小例子。 #include <stdio.h> struct ptr { i
结构体中 “-＞“ 与 “.“ 的区别以及使用
opponent2的博客
09-02 8093
结构体中 “->” 与 “.” 的区别以及使用 两者在同一个代码块内使用的时候其实没有什么太大不同，无非就是声明结构体的时候一个是声明指针，一个是声明结构体。声明结构体的时候分配了内存空间，所以可以用".“直接访问，而声明指针之后并没有分配内存空间，所以用”->“来指向开辟的空间。也可以用”(*buffer).foo" ,等价于"buffer->foo"。 "->"是在声明结构体指针时，访问结构体成员变量时使用。 "."是声明结构体时，访问结构体成员变量时使用。 type
数据结构---单链表的操作
gaoqiandr的博客
10-22 733
对于数据结构链表的详细讲解，简单易懂，非常详细
C语言结构体--指针运算符(“-＞”)和点运算符(“.”) 应用区分
m0_54158068的博客
06-17 7055
指针运算符(“->”) 和 点运算符(“.”) 应用区分
数据结构笔记||栈
weixin_44954209的博客
06-17 690
定义 栈是一种只能在一端进行插入或删除操作的线性表 特点：后进先出 顺序栈 顺序栈s初始时设置s->top=-1，s的4要素 栈空的条件：s->top==-1 栈满的条件：s->top==MaxSize-1(data数组的最大下标) 元素e的进栈操作：先将栈顶指针top增1，然后将元素e放在栈顶指针处 出栈操作：先将栈顶指针top处的元素取出放在e中，然后将栈顶指针减1 算法如下 #include<iostream> #include<cstdlib> us
结构体中 . 和 -＞的区别
m0_50028488的博客
12-15 6068
结构体中 . 和 ->的区别？ 区别： ->：用在结构体指针的时候 . ：用在结构体后面(".“这个运算符可以理解为中文里"的”) 例如：stu.name(stu这个结构体的name这个属性) 想了解"->“这个运算符一定要对”.“运算符比较熟悉，在"数据结构"的学习中会经常用到”->"运算符。 具体区别代码： #include <stdio.h> struct Student{ int age; }st,*p,**p1; int main(void) { p
c/c++中结构体引用中箭头->与点.的区别
08-26
首先介绍一下C++中的结构。对于一个结构来说， struct MyStruct { int member_a; };
matlab中使用结构体汇总.pdf
06-24
matlab中使用结构体汇总.pdfmatlab中使用结构体汇总.pdfmatlab中使用结构体汇总.pdfmatlab中使用结构体汇总.pdfmatlab中使用结构体汇总.pdfmatlab中使用结构体汇总.pdf
C语言之结构体中“ . ”和“ -＞ ”的区别
最新发布
weixin_48867130的博客
09-10 498
为了使用方便和直观，C语言允许把(*temp).score用p->score来替换。不同点：“ . ”操作符左边的操作数是一个“结构体”的表达式，而“ -> ”操作符左边的操作数是一个指向结构体的指针。在这里temp.score代表的是结构体temp里的成员score。相同点：两个操作符都是二元操作符，且其有操作符是结构体成员的名称。所以在结构体中“ . ”和“ -> ”的用法相似，但是并不等价。p->score代表指向temp结构体成员score的指针。
指针与结构体（-＞）
wanghao312的博客
07-14 816
因此，我们可以创建一个指向指针的指针，也就是一个存储指针地址的变量。通过不断更新指向下一个节点的指针，可以在链表中沿着节点之间的连接逐个遍历，直到达到链表的末尾（即指针为NULL）为止。需要注意的是，对于链表遍历操作，需要确保在更新指针之前进行必要的判断和边界检查，以避免在访问节点时出现错误。需要注意的是，类型转换应该谨慎使用，确保数据类型的兼容性和正确性，避免出现潜在的错误。操作符能够自动进行指针解引用，以便访问所指向的结构体或联合体的成员。它是一种简化的写法，通常用于指针访问成员的操作，可以替代使用。
数据结构简记--3
忘三日的博客
09-24 526
数据结构、栈、队列、数组
C++语言中使用结构体时操作符.和-＞的使用及区别
马小超
07-23 1521
总结： 普通结构体使用，可以用.当是用指针指向结构体时，使用->。 (*node).data的作用等于node->data 1、指向不同 一般情况下用“.”，只需要声明一个结构体。格式是，结构体类zhi型名+结构体名。然后用结构体名加dao“.”加域名就可以引用域 了。因为自动分配了结构体的内存。如同 int a;一样。 而用“->”，则要声明一个结构体的指针，还要手动开辟一个该结构体的内存，然后把返回的指针给声明的结构体指针，才能用“->”正确引用。否则...
C语言中，箭头符号 “-＞” 和点号符号 “.”的区别
wanghao312的博客
07-10 1万+
例如，假设有一个结构体类型的指针变量p，其中包含成员变量x，可以使用箭头符号来访问x，例如 p->x。在这个例子中，我们声明了一个指向结构体的指针变量 p2，并使用箭头符号 “->” 通过指针访问结构体的成员。总之，点号和箭头符号在访问结构体或联合体成员时使用的语法和对象类型有所不同，取决于你是直接操作变量还是通过指针访问。箭头符号 “->” 和点号符号 “.” 在C语言中都用于访问结构体或联合体类型的成员，但它们之间有一些重要的区别。来对比点号 “.” 和箭头符号 “->” 的。例子1：使用点号 “.”
栈的基本操作
热门推荐
qq_56683739的博客
08-25 2万+
对于栈这一数据结构，我首先写一下它的基本概念。 栈(stack)是仅限定在表尾进行插入和删除操作的线性表。 栈就是一个线性表，只不过，栈的Insert 和 delete只能在表尾。 普通的线性表，在表中的任意位置都可以进行insert和delete操作。 LIFO: Last In First Out 后进先出，先进后出 栈顶(Top): 进行插入和删除操作的一端 栈底(Bottom) 栈其实我们计算机科学中，更多的一种思想，“先进后出的思想”。 在很...
顺序栈
Lau's Blog
05-07 3518
栈的顺序存储结构定义及其基本运算实现 #include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int top; //栈指针 } SqStack; //顺序栈类型...
c语言用顺序栈显示栈中元素,顺序栈的c语言实现
weixin_36308543的博客
05-22 1779
1.顺序栈结构typedef struct{SElemType data[MAXSIZE];int top; /* 用于栈顶指针 */}SqStack;2.构造一个空栈SStatus InitStack(SqStack *S){/* S.data=(SElemType *)malloc(MAXSIZE*sizeof(SElemType)); */S->top=-1;return OK;}3....
结构体中.和-> 有什么区别
06-07
在结构体中，"."用于访问结构体变量的成员，而"->"用于访问结构体变量的指针所指向的成员。 "."是用于直接访问结构体变量的成员，例如"结构体变量.成员名"，其中的"结构体变量"是一个实际的结构体变量，而"成员名...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值