其他分享
首页 > 其他分享> > 栈与队列简单代码---(顺序栈、链栈、两栈共享空间、循环队列、链队列)

栈与队列简单代码---(顺序栈、链栈、两栈共享空间、循环队列、链队列)

作者：互联网

蠢蠢新手代码有需要的可以参考一下

顺序栈

在这里插入图片描述

//顺序栈入栈出栈
#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
.
.
.
.
.
.
.
.
.
.

头发发我的头发啊啊啊！！！
在这里插入图片描述

标签：return,两栈,队列,LinkNode,top,链栈,int,printf,data
来源： https://blog.csdn.net/homoiotheymy/article/details/120623548