栈的实现
1、顺序栈
1.1顺序栈的基本操作
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#define MaxSize 10
typedef struct{
int data[MaxSize];
int top;
}SqStack;
//初始化顺序栈的栈顶指针，top=-1表示为空栈
void InitSqStack(SqStack *S)
{
S->top=-1;
}
//判断栈是否为空
int StackEmpty(SqStack S)
{
if(S.top==-1)
{
return 1;
}
else
{
return 0;
}
}
//判断栈是否已满
int StackFull(SqStack S)
{
if(S.top==MaxSize-1)
{
return 1;
}
else
{
return 0;
}
}
//入栈操作
int Push(SqStack *S,int e)
{
//先判断顺序栈是否已满
int flag= StackFull(*S);
//flag=1表示顺序栈已满
if(flag==1)
{
//返回0表示push失败
return 0;
}
//先将栈顶指针移到即将入栈的位置
S->top=S->top+1;
S->data[S->top]=e;
return 1;
}
//出站操作
int Pop(SqStack *S)
{
//先判断顺序栈是否为空
int flag=StackEmpty(*S);
//flag=1表示顺序栈为空栈
if(flag==1)
{
//返回0表示pop失败
return 0;
}
int e=S->data[S->top];
printf("删除了%d\n",e);
S->top=S->top-1;
return 1;
}
//读栈顶元素操作
int getTopElement(SqStack S)
{
//先判断顺序栈是否为空
int flag= StackEmpty(S);
//flag=1表示顺序栈为空
if(flag==1)
{
//返回0表示getTopElement失败
return 0;
}
int e=S.data[S.top];
printf("栈顶元素为%d\n",e);
}
//销毁顺序栈
void DestoryStack(SqStack *S)
{
free(S);
S=NULL;
}
int main()
{
SqStack S;
InitSqStack(&S);
int flag=Push(&S,56);
if(flag==1)
{
printf("%d\n",S.data[S.top]);
}
flag= getTopElement(S);
flag= Pop(&S);
return 0;
}
2、共享栈
2.1、共享栈的基本操作
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#define MaxSize 10
//一个顺序栈中存有两个栈，他们的栈顶指针分别为top0和top1
typedef struct{
int data[MaxSize];
int top[2];
}Share_SqStack;
//初始化共享栈的两个栈顶指针，top0=-1，top=MaxSize表示两个顺序栈都为空栈
void InitShare_SqStack(Share_SqStack *S)
{
S->top[0]=-1;
S->top[1]=MaxSize;
}
//判断共享栈是否已满
int Share_SqStackFull(Share_SqStack S)
{
if(S.top[0]+1==S.top[1])
{
return 1;
}
else
{
return 0;
}
}
//判断共享栈是否为空栈，根据栈顶序号判断此时的栈是否为空栈
int Share_SqStackEmpty(Share_SqStack S,int top_num)
{
if(S.top[top_num]==MaxSize || S.top[top_num]==-1)
{
//返回1，表示此时栈顶号对应的顺序栈为空栈
return 1;
}
else
{
//返回0，表示此时栈顶号对应的顺序栈不为空栈
return 0;
}
}
//共享栈的入栈操作
int Push(Share_SqStack* S,int top_num,int e)
{
//判断top_num值的合法性
if(top_num!=0 && top_num!=1)
{
printf("栈顶序号有误！！！\n");
//返回0，表示Push失败
return 0;
}
//判断共享栈是否栈满
int flag= Share_SqStackFull(*S);
//栈满，push操作失败
if(flag==1)
{
printf("栈满，入栈失败！！！\n");
return 0;
}
//状态码为0，表示此时top_num号顺序栈未满，可以执行入栈操作
//当栈顶号为0号时，入栈时栈顶指针递增
if(top_num==0)
{
S->top[top_num]++;
S->data[S->top[top_num]]=e;
//返回1，表示Push成功
return 1;
}
//当栈顶号为1号时，入栈时栈顶指针递减
else
{
S->top[top_num]--;
S->data[S->top[top_num]]=e;
//返回1，表示Push成功
return 1;
}
}
//共享栈的出站操作
int Pop(Share_SqStack* S,int top_num)
{
//检测top_num的合法性，不合法直接结束并返回状态码0
if(top_num!=1 && top_num!=0)
{
printf("栈顶序号有误！！！\n");
return 0;
}
//判断共享栈的top_num号顺序栈是否为空栈
int flag= Share_SqStackEmpty(*S,top_num);
//状态码为1，表示为空栈
if(flag==1)
{
printf("空栈，出栈失败！！！\n");
//返回0，表示Pop失败
return 0;
}
//状态码为0，表示此时top_num号顺序栈不为空栈，可以执行出栈操作
//当栈顶号为0号时，出栈时栈顶指针递减
if(top_num==0)
{
int e=S->data[S->top[top_num]];
printf("删除了%d\n",e);
S->top[top_num]--;
//返回1，表示Pop成功
return 1;
}
//当栈顶号为1号时，出栈时栈顶指针递增
else
{
int e=S->data[S->top[top_num]];
printf("删除了%d\n",e);
S->top[top_num]++;
//返回1，表示Pop成功
return 1;
}
}
void printShare_SqStack(Share_SqStack S)
{
int i;
int top0=S.top[0];
int top1=S.top[1];
printf("(栈顶指针,元素)\n");
//打印栈顶号为1的顺序栈
for(i=MaxSize-1;i>=top1;i--)
{
printf("(%d,%d)\n",i,S.data[i]);
}
//打印栈顶号为0的顺序栈
for(i=top0;i>=0;i--)
{
printf("(%d,%d)\n",i,S.data[i]);
}
}
//销毁共享栈
void DestoryShare_SqStack(Share_SqStack *S)
{
free(S);
S=NULL;
}
int main()
{
int flag,i;
Share_SqStack S;
//初始化共享栈
InitShare_SqStack(&S);
//向栈顶号为0的顺序栈插入数据
for(i=0;i<4;i++)
{
flag= Push(&S,0,12345);
if(flag==1)
{
printf("入栈成功！\n");
}
}
//向栈顶号为1的顺序栈插入数据
for(i=0;i<3;i++)
{
flag= Push(&S,1,54321);
if(flag==1)
{
printf("入栈成功！\n");
}
}
//打印入栈后的共享栈
printShare_SqStack(S);
//向栈顶号为0的顺序栈删除数据
for(i=0;i<2;i++)
{
flag= Pop(&S,0);
if(flag==1)
{
;
}
}
//向栈顶号为1的顺序栈删除数据
for(i=0;i<2;i++)
{
flag= Pop(&S,1);
if(flag==1)
{
;
}
}
//打印出栈后的共享栈
printShare_SqStack(S);
//销毁共享栈
DestoryShare_SqStack(&S);
return 0;
}
3、链栈
3.1、链栈的基本操作
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct LinkStack{
int data;
struct LinkStack* next;
}LinkStackNode,*LinkStack;
//初始化链栈
void InitLinkStack(LinkStack L)
{
L->next=NULL;
}
//判断链栈是否为空
int LinkStackEmpty(LinkStack L)
{
if(L->next==NULL)
{
return 1;
}
else
{
return 0;
}
}
//入栈
int Push(LinkStack L,int e)
{
//创建一个结点,若空间申请失败，返回0
LinkStackNode *s=(LinkStackNode *) malloc(sizeof(LinkStackNode));
if(s==NULL)
{
return 0;
}
LinkStackNode *p=L;
s->data=e;
s->next=p->next;
p->next=s;
return 1;
}
//出栈
int Pop(LinkStack L)
{
//判断链栈是否为空栈
int flag= LinkStackEmpty(L);
if(flag==1)
{
return 0;
}
//p指针指向待删除的结点
LinkStackNode *p=L->next;
L->next=p->next;
printf("删除了%d\n",p->data);
//释放被删除结点的内存空间
free(p);
return 1;
}
//链栈的长度计算
int length(LinkStack L)
{
LinkStackNode *p=L;
int len=0;
while(p->next!=NULL)
{
p=p->next;
len++;
}
return len;
}
//按位查找
int GetElement(LinkStack L,int locate)
{
//判断链栈是否为空栈
int flag= LinkStackEmpty(L);
if(flag==1)
{
printf("空栈！\n");
return -1;
}
//判断locate值是否合法
int len= length(L);
if(locate<1 || locate>len)
{
printf("位置有误！\n");
return -1;
}
//指针p指向第一个结点
LinkStackNode *p=L->next;
int i=1;
while (p!=NULL && i<locate)
{
p=p->next;
i++;
}
return p->data;
}
//按值查找
int GetLocate(LinkStack L,int e)
{
//判断链栈是否为空栈
int flag= LinkStackEmpty(L);
if(flag==1)
{
printf("空栈！\n");
return -1;
}
//指针p指向第一个结点
LinkStackNode *p=L->next;
int i=1;
while(p!=NULL && p->data!=e)
{
p=p->next;
i++;
}
if(p->data=e)
{
return i;
}
else
{
printf("未找到！\n");
return -1;
}
}
//打印链栈
void printLinkStack(LinkStack L)
{
LinkStackNode *p=L;
while (p->next!=NULL)
{
p=p->next;
printf("%d",p->data);
printf("\n");
}
}
int main()
{
//创建一个头结点
LinkStack L=(LinkStackNode *) malloc(sizeof(LinkStackNode));
InitLinkStack(L);
//入栈
int flag;
for(int i=0;i<6;i++)
{
flag= Push(L,i*i);
if(flag==1)
{
printf("入栈成功！\n");
}
}
//打印入栈后的链栈
printLinkStack(L);
//出栈
for(int i=0;i<3;i++)
{
flag= Pop(L);
if(flag==1)
{
printf("出栈成功！\n");
}
}
//打印出栈后的链栈
printLinkStack(L);
//按值查找
int locate= GetLocate(L,4);
if(locate!=-1)
{
printf("在第%d个\n",locate);
}
//按位查找
int ele= GetElement(L,3);
if(ele!=-1)
{
printf("值为%d\n",ele);
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
