蠢蠢新手代码有需要的可以参考一下
顺序栈
//顺序栈入栈出栈
#include<stdio.h>
#include<stdlib.h>
#define Max 100
typedef struct stack{
int data[Max];
int top;
}Sqstack;
//初始化
int Init(Sqstack *s){
s->top=(Sqstack *)malloc(Max*sizeof(Sqstack));
s->top=0;
return 1;
}
//入栈
int Push(Sqstack *s, int i){
if(s->top==Max-1) //栈满
return 0;
s->data[++s->top]=i; //在栈顶放元素
return 1;
}
//出栈
int Pop(Sqstack *s, int *e){
if(s->top==-1) //栈空
return 0;
*e=s->data[s->top--]; //top下移
return 1;
}
//遍历
int Traverse(Sqstack *s){
int i=0;
while(i++<s->top){
printf("%d ",s->data[i]);
}
printf("\n");
return 1;
}
int main(){
Sqstack *s;
Init(s);
int n,e;
printf("输入添加栈元素的个数:\n");
scanf("%d",&n);
for(int i=1;i<=n;i++){
Push(s,i);
}
Traverse(s);
Pop(s,&e);
printf("出栈掉的元素是：%d\n",e);
Traverse(s);
return 0;
}
链栈
//链栈入栈出栈
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct stacknode{
ElemType data;
struct stacknode *next;
}LinkNode; //操作数据
typedef struct{
LinkNode *top;
int Length;
}LinkStack; //操作栈头
//初始化创建
int Init(LinkStack *p){
p->top=(LinkNode *)malloc(sizeof(LinkNode)); //为top申请一个data.next域的结点
p->top=NULL;
p->Length=0;
return 1;
}
//空
int StackEmpty(LinkStack St){
if(St.Length==0){
return 1;
}
else{
return 0;
}
}
//入栈
int Push(LinkStack *St, ElemType e){
LinkNode *s;
s=(LinkNode *)malloc(sizeof(LinkNode));
s->data=e;
s->next=St->top;
St->top=s;
St->Length++;
return 1;
}
//弹出
int Pop(LinkStack *St, ElemType *e){
LinkNode *t;
if(StackEmpty(*St)){ //不为空就表示if无效
return 0;
}
*e=St->top->data;
t=St->top;
St->top=St->top->next;
free(t);
St->Length--;
return 1;
}
//遍历
int Traverse(LinkStack *St){
LinkNode *st;
st=St->top;
while(st){
printf("%d ",st->data);
st=st->next;
}
printf("\n");
return 1;
}
int main(){
LinkStack *L;
ElemType e;
Init(L);
for(int i=1;i<=5;i++){
Push(L,i);
}
Traverse(L);
Pop(L,&e);
printf("出掉的栈头是：%d\n",e);
Traverse(L);
return 0;
}
两栈共享空间
//两栈共享空间
#include<stdio.h>
#include<stdlib.h>
#define Max 10
typedef struct{
int data[Max];
int top1;
int top2;
}Dustack;
//初始化
int Init(Dustack *s){
s->top1=-1;
s->top2=Max;
return 1;
}
//入栈
int Push(Dustack *s, int i, int stackNum){
if(s->top1+1==s->top2) //栈满
return 0;
if(stackNum==1)
s->data[++s->top1]=i; //栈1从前面添加
else if(stackNum==2)
s->data[--s->top2]=i; //栈2从后面添加
return 1;
}
//出栈
int Pop(Dustack *s, int stackNum, int *e){
if(stackNum==1){
if(s->top1==-1) //栈1不为空
return 0;
*e=s->data[s->top1--]; //出栈1的栈顶
}else if(stackNum==2){
if(s->top2==Max) //栈2不为空
return 0;
*e=s->data[s->top2++]; //出栈2的栈顶
}
return 1;
}
//遍历
int Traverse(Dustack s){
int i=0;
printf("表:"); //分别输出栈1和栈2
while(i<=s.top1){
printf("%d ",s.data[i++]);
}
while(s.top2<Max){
printf("%d ",s.data[s.top2++]);
}
printf("\n");
return 1;
}
int Length(Dustack s){
return (s.top1+1)+(Max-s.top2);
}
int main(){
Dustack s;
int e;
Init(&s);
for(int i=1;i<Max-5;i++){
Push(&s,i,1); //从前面添加元素
}
for(int i=1;i<Max-4;i++){
Push(&s,Max+i,2); //从后面添加元素
}
Traverse(s);
Pop(&s,1,&e);
printf("出栈栈1的头：%d\n",e);
Traverse(s);
Pop(&s,2,&e);
printf("出栈栈2的头：%d\n",e);
Traverse(s);
return 0;
}
循环队列
//循环队列
//循环也是就说%Max让它回到前面
#include<stdio.h>
#include<stdlib.h>
#define Max 5
typedef struct{
int data[Max];
int front;
int rear;
}SqQueue;
//初始化
int InitQueue(SqQueue *Q){
Q->front=0;
Q->rear=0;
return 1;
}
//长度
int QueueLength(SqQueue *Q){
return (Q->rear - Q->front+Max)%Max;
}
//入列
int EnQueue(SqQueue *Q, int e){
if((Q->rear+1)%Max==Q->front) //栈满,留一个位置
return 0;
Q->data[Q->rear]=e;
Q->rear=(Q->rear+1)%Max; //不为满的情况下*移动
return 1;
}
//出列
int DeQueue(SqQueue *Q, int *e){
if(Q->front==Q->rear) //栈空
return 0;
*e=Q->data[Q->front];
Q->front=(Q->front+1)%Max; //不为空的情况下*移动
return 1;
}
//遍历
int Traverse(SqQueue *Q){
SqQueue *q=Q;
int i=q->front; //遍历的条件跟判断栈空的条件是一样的，不过这里用了i
while(i!=q->rear){ //因为判断栈满所以少了一个空间
printf("%d ",q->data[i]);
i=(i+1)%Max;
}
printf("\n");
}
int main(){
SqQueue *Q;
int e;
InitQueue(Q);
for(int i=1 ;i<=Max;i++){
EnQueue(Q,i);
}
Traverse(Q);
DeQueue(Q,&e);
printf("出栈的元素是：%d\n",e);
Traverse(Q);
return 0;
}
链队列
//链栈
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct node{
ElemType data;
struct node *next;
}LinkNode;
typedef struct{
LinkNode *front,*rear;
}LinkQueue;
//初始化创建
int InitQueue(LinkQueue *Q){
LinkNode *head;
head=(LinkNode *)malloc(sizeof(LinkNode));
Q->front=Q->rear=head;
return 1;
}
//入列
int EnQueue(LinkQueue *Q, ElemType e){
LinkNode *q;
q=(LinkNode *)malloc(sizeof(LinkNode));
q->data=e;
q->next=NULL;
Q->rear->next=q; //和尾插法差不多
Q->rear=q;
return 1;
}
//出列
int DeQueue(LinkQueue *Q, ElemType *e){
LinkNode *q;
if(Q->front==Q->rear) //判空，判满就不必了因为是链式结构
return 0;
q=Q->front->next;
*e=q->data;
Q->front->next=q->next; //和链表删除没有区别
if(Q->rear=q) //若队头是队尾，删除后将rear指向头结点
Q->rear=Q->front;
free(q);
return 1;
}
//遍历
int Traverse(LinkQueue *Q){
LinkNode *q;
q=Q->front->next; //头结点哦！
while(q){
printf("%d ",q->data);
q=q->next;
}
printf("\n");
return 1;
}
int main(){
LinkQueue *Q;
ElemType e;
InitQueue(Q);
for(int i=1;i<=5;i++){
EnQueue(Q,i);
}
Traverse(Q);
DeQueue(Q,&e);
printf("出列的栈头是：%d\n",e);
Traverse(Q);
return 0;
}
END
.
.
.
.
.
.
.
.
.
.
头发发我的头发啊啊啊！！！