[数据结构]栈与队列

原创

animalslin 2022-06-28 23:29:46 博主文章分类：数据结构 ©著作权

文章标签 data structure #include 出队 #define 文章分类 数据结构与算法人工智能

©著作权归作者所有：来自51CTO博客作者animalslin的原创作品，请联系作者获取转载授权，否则将追究法律责任

[数据结构]栈与队列_data structure

1.2 栈和队列

1.2.1 用数组仿真堆栈
1.2.2 用链表仿真堆栈
1.2.3 顺序栈公用
1.2.4 进制转换问题
1.2.5 顺序队列操作
1.2.6 循环队列
1.2.7 链队列的入队、出队
1.2.8 舞伴问题
1.2.9 动态堆栈
1.2.10 动态队列

1.2 栈和队列

1.2.1 用数组仿真堆栈

#include"stdio.h"
#define MaxSize 10
int stack[MaxSize];
int top=-1;
void push(int value)
{
    int i;
    if(top>=MaxSize)
        printf("\nThe stack is full!\n");
    else
        {
            printf("\nThe stack content before(top->bottom):");
            for(i=top;i>=0;i--)
                printf("[%d]",stack[i]);
            top++;
            stack[top]=value;
            printf("\nThe stack content after push(top->bottom):");
            for(i=top;i>=0;i--)
                printf("[%d]",stack[i]);
            printf("\n");
        }
}
int pop()
{
    int temp;
    int i;
    if(top<0)
        {
            printf("\nThe stack is empty!\n");
            return -1;
        }
        printf("\nThe stack content before(top->bottom):");
        for(i=top;i>=0;i--)
            printf("[%d]",stack[i]);
        temp=stack[top];
        top--;
        printf("\nThe pop value is [%d]",temp);
        printf("\nThe stack content after pop(top->bottom):");
        for(i=top;i>=0;i--)
                printf("[%d]",stack[i]);
            printf("\n");
        return temp;
}
int main()
{
    int select;
    int stack[5];
    int i,value;
    printf("\n(1)Input a stack data");
    printf("\n(2)Output a stack data");
    printf("\n(3)Exit");
    printf("\nPlease select one=>");
    scanf("%d",&select);
    do
    {
        switch(select)
        {
            case 1:printf("\nPlease input the data=>");
            scanf("%d",&value);
            push(value);
            break;
            case 2:value=pop();
            break;
        }
        printf("\n(1)Input a stack data");
        printf("\n(2)Output a stack data");
        printf("\n(3)Exit");
        printf("\nPlease select one=>");
        scanf("%d",&select);
        printf("\n");
    }while(select!=3);
    return 0;
}

运行结果
[数据结构]栈与队列_出队_02

1.2.2 用链表仿真堆栈

#include <malloc.h>
#include"stdio.h"
struct s_node
{
    int data;
    struct s_node *next;
};
typedef struct s_node s_list;
typedef    s_list *link;
link stack=NULL;
void print_stack()
{
    link temp=NULL;
    temp=stack;
    if(temp==NULL)
        printf("The stack is empty!\n");
    else
    {
        while(temp!=NULL)
        {
            printf("[%d]",temp->data);
            temp=temp->next;
        }
        printf("\n");
    }
}
void push(int value)
{
    link newnode;
    printf("\nThe stack content before(top->bottom):");
    print_stack();
    newnode=(link)malloc(sizeof(s_list));
    newnode->data=value;
    newnode->next=stack;
    stack=newnode;
}
int pop()
{
    link top;
    int temp;
    printf("\nThe stack content before(top->bottom):");
    print_stack();
    if(stack!=NULL)
    {
        top=stack;
        stack=stack->next;
        temp=top->data;
        free(top);
        return temp;
    }
    else
        return -1;
}
int main()
{
    link point;
    int select;
    int i,value;
    printf("\n(1)Input a stack data");
    printf("\n(2)Output a stack data");
    printf("\n(3)Exit");
    printf("\nPlease select one=>");
    scanf("%d",&select);
    do
    {
        switch(select)
        {
            case 1:printf("\nPlease input the data=>");
                scanf("%d",&value);
                push(value);
                printf("\nThe stack content current(top->bottom):");
                print_stack();
                break;
            case 2:value=pop();
                printf("\nThe output value is [%d]",value);
                printf("\n");
                printf("The stack content currnet(top->bottom):");
                print_stack();
                break;
        }
        printf("\n(1)Input a stack data");
        printf("\n(2)Output a stack data");
        printf("\n(3)Exit");
        printf("\nPlease select one=>");
        scanf("%d",&select);
    }while(select!=3);
    return 0;
}

运行结果
[数据结构]栈与队列_#define_03

1.2.3 顺序栈公用

#include "stdio.h"
#define MEMORY_SIZE  100  /* 内存大小 */
#define MAX_STACKS 10      /* 栈的个数加1*/
typedef char element;
element memory [MEMORY_SIZE];
int top[MAX_STACKS-1];
int boundary[MAX_STACKS];
/* 置栈空*/
void Initial(int n)
{/*将各个顺序栈置空*/
    int i;
    top [0] = boundary [0] = -1;
    for ( i =1;  i<n;  i ++ )
        top[i]=boundary[i]= (MEMORY_SIZE/n)*i;
    boundary[n]=MEMORY_SIZE-1;
}
/*进栈*/
void Push(int i, element item)
{
    if (top[i] == boundary[i+1] )
    {
        printf("第%d个栈已满。",i);
    }
    memory[++top[i]] = item;
}
/*退栈*/
element Pop(int i)
{
    if ( top[i] == boundary[i] )
    {
        printf("第%d个栈已空。",i);
    }
    return memory[top[i]--];
}
int main()
{
    int  n=2;      /* 使用的栈的个数 */
    element first,sec;
    Initial(n);
    Push(1,'a');
    Push(0,'b');
    sec=Pop(1);
    first=Pop(0);
    return 0;
}

1.2.4 进制转换问题

#include "stdio.h"
#include "stdlib.h"
#define StackSize 100 /*假定预分配的栈空间最多为100个元素*/
typedef int DataType;/*假定栈元素的数据类型为字符*/
typedef struct{
      DataType data[StackSize];
      int top;
}SeqStack;
/* 置栈空*/
void Initial(SeqStack *S)
{/*将顺序栈置空*/
      S->top=-1;
}
/*判栈空*/
int IsEmpty(SeqStack *S)
{
    return S->top==-1;
}
/*判栈满*/
int IsFull(SeqStack *S)
{
    return S->top==StackSize-1;
}
/*进栈*/
void Push(SeqStack *S,DataType x)
{
    if (IsFull(S))
    {
        printf("栈上溢"); /*上溢,退出运行*/
        exit(1);
    }
    S->data[++S->top]=x;/*栈顶指针加1后将x入栈*/
}
/*出栈*/
DataType Pop(SeqStack *S)
{
    if(IsEmpty(S))
    {
        printf("栈为空"); /*下溢,退出运行*/
        exit(1);
    }
    return S->data[S->top--];/*栈顶元素返回后将栈顶指针减1*/
}
/* 取栈顶元素*/
DataType Top(SeqStack *S)
{
    if(IsEmpty(S))
    {
        printf("栈为空"); /*下溢,退出运行*/
        exit(1);
    }
    return S->data[S->top];
}
void MultiBaseOutput (int N,int B)
{/*假设N是非负的十进制整数，输出等值的B进制数*/
    int i;
    SeqStack S;
    Initial(&S);
    while(N){  /*从右向左产生B进制的各位数字，并将其进栈*/
        Push(&S,N%B); /*将bi进栈0<=i<=j*/
        N=N/B;
    }
    while(!IsEmpty(&S)){  /*栈非空时退栈输出*/
        i=Pop(&S);
        printf("%d",i);
    }
}
int main()
{
    MultiBaseOutput(1023,2);
    return 0;
}

运行结果
[数据结构]栈与队列_data structure_04

1.2.5 顺序队列操作

#include "stdio.h"
#include "stdlib.h"
#define QueueSize 100 /*假定预分配的队列空间最多为100个元素*/
typedef int DataType;/*假定队列元素的数据类型为字符*/
typedef struct{
      DataType data[QueueSize];
      int front;/*头指针*/
      int rear;/*尾指针*/
}SeqQueue;
/* 置队列空*/
void Initial(SeqQueue *Q)
{/*将顺序队列置空*/
      Q->front=Q->rear=0;
}
/*判队列空*/
int IsEmpty(SeqQueue *Q)
{
    return Q->front==Q->rear;
}
/*判队列满*/
int IsFull(SeqQueue *Q)
{
    return Q->rear==QueueSize-1+Q->front;
}
/*进队列*/
void Push(SeqQueue *Q,DataType x)
{
    if (IsFull(Q))
    {
        printf("队列上溢"); /*上溢,退出运行*/
        exit(1);
    }
    Q->data[Q->rear++]=x;/*队列顶指针加1后将x入队列*/
}
/*出队列*/
DataType Pop(SeqQueue *Q)
{
    if(IsEmpty(Q))
    {
        printf("队列为空"); /*下溢,退出运行*/
        exit(1);
    }
    return Q->data[Q->front++];/*队列顶元素返回后将队列顶指针减1*/
}
/* 取队列顶元素*/
DataType Top(SeqQueue *Q)
{
    if(IsEmpty(Q))
    {
        printf("队列为空"); /*下溢,退出运行*/
        exit(1);
    }
    return Q->data[Q->front];
}

int main()
{
    SeqQueue s;
    DataType first,sec;
    Initial(&s);
    Push(&s,'a');
    Push(&s,'b');
    first=Top(&s);
    Pop(&s);
    sec=Top(&s);
    Pop(&s);
    return 0;
}

1.2.6 循环队列

#include "stdio.h"
#include "stdlib.h"
#define QueueSize 100 /*假定预分配的队列空间最多为100个元素*/
typedef int DataType;/*假定队列元素的数据类型为字符*/
typedef struct{
    DataType data[QueueSize];
    int front;/*头指针*/
    int rear;/*尾指针*/
    int count; /*计数器，记录队中元素总数*/
}CirQueue;
/* 置队列空*/
void Initial(CirQueue *Q)
{/*将顺序队列置空*/
    Q->front=Q->rear=0;
    Q->count=0;     /*计数器置0*/
}
/* 判队列空*/
int IsEmpty(CirQueue *Q)
{
    return Q->front==Q->rear;
}
/*判队列满*/
int IsFull(CirQueue *Q)
{
    return Q->rear==QueueSize-1+Q->front;
}
/*进队列*/
void EnQueue(CirQueue *Q,DataType x)
{
    if (IsFull(Q))
    {
        printf("队列上溢"); /*上溢,退出运行*/
        exit(1);
    }
    Q->count ++;                        /*队列元素个数加1*/
    Q->data[Q->rear]=x;                 /*新元素插入队尾*/
    Q->rear=(Q->rear+1)%QueueSize;      /*循环意义下将尾指针加1*/
}
/*出队列*/
DataType DeQueue(CirQueue *Q)
{
    DataType temp;
    if(IsEmpty(Q))
    {
        printf("队列为空"); /*下溢,退出运行*/
        exit(1);
    }
    temp=Q->data[Q->front];
    Q->count--;                        /*队列元素个数减1*/
    Q->front=(Q->front+1)&QueueSize;   /*循环意义下的头指针加1*/
    return temp;

}
/* 取队列顶元素*/
DataType Front(CirQueue *Q)
{
    if(IsEmpty(Q))
    {
        printf("队列为空"); /*下溢,退出运行*/
        exit(1);
    }
    return Q->data[Q->front];
}

int main()
{
    CirQueue s;
    DataType first,sec;
    Initial(&s);
    EnQueue(&s,'a');
    EnQueue(&s,'b');
    first=Front(&s);
    DeQueue(&s);
    sec=Front(&s);
    DeQueue(&s);
    return 0;
}

1.2.7 链队列的入队、出队

#include "stdio.h"
#include "stdlib.h"
#define QueueSize 100 /*假定预分配的队列空间最多为100个元素*/
typedef char DataType ; /*假定队列元素的数据类型为字符*/
typedef struct node{
    DataType data;
    struct node *next;
}QueueNode;
typedef struct{
    QueueNode *front;  /*头指针*/
    QueueNode *rear;
}LinkQueue;
/* 置队列空*/

void Initial(LinkQueue *Q)
/*将顺序队列置空*/

{    Q->front=Q->rear=NULL;
}

/*判队列空*/
int IsEmpty(LinkQueue *Q)
{
    return Q->front==NULL&&Q->rear==NULL;
}

/*进队列*/
void Push(LinkQueue *Q,DataType x)
{
/*将元素x插入链队列尾部*/
    QueueNode *p=(QueueNode *)malloc(sizeof(QueueNode));/*申请新结点*/
    p->data=x;
    p->next=NULL;
    if(IsEmpty(Q))
        Q->front=Q->rear=p;  /*将x插入空队列*/
    else
    { /*x插入非空队列的尾*/
        Q->rear->next=p;     /*p链到原队尾结点后*/
        Q->rear=p;           /*队尾指针指向新的尾*/
    }
}

/*出队列*/
DataType Pop(LinkQueue *Q)
{
    DataType x;
    QueueNode *p;
    if(IsEmpty(Q))
    {
        printf("队列为空");/*下溢*/
        exit(1);
    }
    p=Q->front;                   /*指向对头结点*/
    x=p->data;                    /*保存对头结点的数据*/
    Q->front=p->next;             /*将对头结点从链上摘下*/
    if(Q->rear==p)/*原队中只有一个结点，删去后队列变空，此时队头指针已为空*/
        Q->rear=NULL;
    free(p);   /*释放被删队头结点*/
    return x;  /*返回原队头数据*/
}

/* 取队列顶元素*/
DataType Front(LinkQueue *Q)
{
    if(IsEmpty(Q))
    {
        printf("队列为空"); /*下溢,退出运行*/
        exit(1);
    }
    return Q->front->data;
}

int main()
{
    LinkQueue s;
    DataType first,sec;
    Initial(&s);
    Push(&s,'a');
    Push(&s,'b');
    first=Front(&s);
    Pop(&s);
    sec=Front(&s);
    Pop(&s);
    return 0;
}

1.2.8 舞伴问题

#include "stdio.h"
#include "stdlib.h"
#define MAX_DANCERS 100//最多跳舞人数
#define QueueSize 100 //假定预分配的队列空间最多为100个元素
typedef struct{
    char name[20];
    char sex;  //性别，'F'表示女性，'M'表示男性
}Person;
typedef Person DataType;  //将队列中元素的数据类型改为Person
typedef struct{
    DataType data[QueueSize];
    int front;//头指针
    int rear;//尾指针
    int count; //计数器，记录队中元素总数
}CirQueue;
// 置队列空
void Initial(CirQueue *Q)
{//将顺序队列置空
    Q->front=Q->rear=0;
    Q->count=0;     //计数器置0
}
//判队列空
int IsEmpty(CirQueue *Q)
{
    return Q->front==Q->rear;
}
//判队列满
int IsFull(CirQueue *Q)
{
    return Q->rear==QueueSize-1+Q->front;
}
//进队列
void EnQueue(CirQueue *Q,DataType x)
{
    if (IsFull(Q))
    {
        printf("队列上溢"); //上溢,退出运行
        exit(1);
    }
    Q->count ++;                        //队列元素个数加1
    Q->data[Q->rear]=x;                 //新元素插入队尾
    Q->rear=(Q->rear+1)%QueueSize;      //循环意义下将尾指针加1
}
//出队列
DataType DeQueue(CirQueue *Q)
{
    DataType temp;
    if(IsEmpty(Q))
    {
        printf("队列为空"); //下溢,退出运行
        exit(1);
    }
    temp=Q->data[Q->front];
    Q->count--;                        //队列元素个数减1
    Q->front=(Q->front+1)&QueueSize;   //循环意义下的头指针加1
    return temp;

}
// 取队列顶元素
DataType Front(CirQueue *Q)
{
    if(IsEmpty(Q))
    {
        printf("队列为空"); //下溢,退出运行
        exit(1);
    }
    return Q->data[Q->front];
}
void DancePartner(Person dancer[],int num)
{//结构数组dancer中存放跳舞的男女，num是跳舞的人数。
    int i;
    Person p;
    CirQueue Mdancers,Fdancers;
    Initial(&Mdancers);//男士队列初始化
    Initial(&Fdancers);//女士队列初始化
    for(i=0;i<num;i++){//依次将跳舞者依其性别入队
        p=dancer[i];
        if(p.sex=='F')
            EnQueue(&Fdancers,p);   //排入女队
        else
            EnQueue(&Mdancers,p);   //排入男队
    }
    printf("dance queue is:\n");
    while(!IsEmpty(&Fdancers)&&!IsEmpty(&Mdancers)){
        //依次输入男女舞伴名
        p=DeQueue(&Fdancers);     //女士出队
        printf("%s        ",p.name);//打印出队女士名
        p=DeQueue(&Mdancers);     //男士出队
        printf("%s\n",p.name);    //打印出队男士名
    }
    if(!IsEmpty(&Fdancers)){ //输出女士剩余人数及队头女士的名字
        printf("still have %d landy wait next.\n",Fdancers.count);
        p=Front(&Fdancers);  //取队头
        printf("%s will be the first to get a partner. \n",p.name);
    }
    else if(!IsEmpty(&Mdancers)){//输出男队剩余人数及队头者名字
        printf("still have %d man wait next.\n",Mdancers.count);
        p=Front(&Mdancers);
        printf("%s will be the first to get a partner.\n",p.name);
    }
}
void InitialDancer(Person dancer[])
{
    //跳舞报名
}
int main()
{
    Person dancer[MAX_DANCERS];
    int n=93;
    InitialDancer(dancer);
    DancePartner(dancer,93);
    return 0;
}

运行结果
[数据结构]栈与队列_出队_05

1.2.9 动态堆栈

#include "stdio.h"
#include "stdlib.h"

typedef char datatype;
typedef struct node {
    datatype data;
    struct node *next;
} stack;

int Empty(stack *s) {
    return (s == NULL);
}

stack *creat(void) {
    char ch;
    stack *head;
    stack *p;
    head = NULL;/*初始化为空*/
    ch = getchar();
    while (ch != '\n') {
        p = (stack *) malloc(sizeof(stack));/*分配空间*/
        p->data = ch;/*数据域赋值*/
        p->next = head;/*指定后继指针*/
        head = p;/*head指针指定到新插入的结点上*/
        ch = getchar();
    }
    return (head);
}

void MakeNull(stack *s)/*使栈s为空*/
{
    stack *p = s;
    while (s != NULL) {
        s = s->next;
        free(p);/*释放空间*/
        p = s;
    }
}

datatype Top(stack *s) {
    if (Empty(s))/*s为空栈，直接跳出，提示出错信息*/
        printf("The stack is empty.");
    else
        return s->data;
}

void Pop(stack *s) {
    stack *p;
    if (Empty(s)) /*s为空栈，直接跳出，提示出错信息*/
        printf("The stack is empty.");
    else {
        p = s;
        s = s->next;
        free(p);/*释放栈顶空间*/
    }
}

void Push(stack *s, datatype x) {
    stack *p;
    p = (stack *) malloc(sizeof(stack));
    p->data = x;
    p->next = s;
    s = p;
}

int main() {
    stack *m_stack = creat();
    char m_top;
    if (!Empty(m_stack)) {
        m_top = Top(m_stack);
        Pop(m_stack);
    } else
        Push(m_stack, 'a');
    MakeNull(m_stack);
    return 0;
}

1.2.10 动态队列

#include "stdio.h"
#include "stdlib.h"

typedef char datatype;
typedef struct node {
    datatype data;
    struct node *next;
} position;
typedef struct queue {
    position *front;
    position *rear;
} queuetype;

/*判断是否为空队列：*/
int Empty(queuetype *q) {
    return (q->front == q->rear);
}

/*使队列为空：*/
void MakeNull(queuetype *q) {
    q->rear = q->front;
    while (q->front != NULL) {
        q->front = q->front->next;
        free(q->rear);/*释放空间*/
        q->rear = q->front;
    }
    q->front = (position *) malloc(sizeof(position));
    q->front->next = NULL;
    q->rear = q->front;
}

/* 取队列的队头元素：*/
datatype Front(queuetype *q) {
    if (Empty(q))
        printf("'The queue is empty!");
    else
        return (q->front->next->data);
}

/*删除队列头元素：*/
void dequeue(queuetype *q) {
    position *p;
    if (Empty(q))
        printf("The queue is empty!");
    else {
        p = q->front;
        q->front = q->front->next;
        free(p);
    }
}

/* 在队列中加入新元素：*/
void Enqueue(datatype x, queuetype *q) {
    position *p;
    p = (position *) malloc(sizeof(position));
    p->data = x;
    p->next = NULL;
    q->rear->next = p;
    q->rear = p;
}

int main() {
    queuetype *m_q;
    char m_top;
    m_q = (queuetype *) malloc(sizeof(queuetype));
    m_q->front = m_q->rear = (position *) malloc(sizeof(position));
    m_q->rear->next = NULL;
    if (!Empty(m_q)) {
        m_top = Front(m_q);
        dequeue(m_q);
    } else
        Enqueue('c', m_q);
    MakeNull(m_q);
    return 0;
}

Talk is cheap. Show me the code

上一篇：百度高效研发实战训练营-Step3

下一篇：[数据结构]数据结构复习总结

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯