栈和队列的代码实现

栈

什么是栈

栈是一种数据结构

• 栈可以用来存放数字一次只能向栈里加入一个数字，一次也只能从栈里获得一个数字
• 栈里的数字有前后顺序，先进入的数字在前，后进入的数字在后
• 每次从栈里获得的数字一定是最后面的数字，最后获取的数字一定是最前面的数字
• 这种使用数字的方法叫先进后出后进先出

栈的表示

//结构体类型，表示栈
typedef struct stack{
    int* arr; //记录存储区的首地址
    int top;//即将存入的元素下标
    int cap;// 容量
}stack_t;

 栈的操作

• 向栈里加入数字的函数通常叫push，入栈
• 从栈里获得数字的函数通常叫pop，出栈

栈的初始化

//栈的初始化
//stack_t sk
//stack_init(5,&sk)
void stack_init(int cap,stack_t* s){
    s->cap = cap;
    s->arr = malloc(sizeof(int) * cap);
    s->top = 0;
}

栈的释放

//栈的释放
void stack_deinit(stack_t* s){
    free(s->arr);
    s->arr = NULL;
    s->top = 0;
    s->cap = 0;
}

栈的判满

//栈的判满
int stack_full(stack_t* s){
    if(s->top == s->cap){
        return 1;
    }else{
        return 0;
    }
}

栈的判空

//栈的判空
int stack_empty(stack_t* s){
    if(s->top == 0){
        return 1;
    }else{
        return 0;
    }
}

压栈

//压栈
void stack_push(stack_t* s,int data){
    s->arr[s->top] = data;
    s->top++;
}

弹栈

//弹栈
int stack_pop(stack_t* s){
    return s->arr[--s->top];
}

在main.c文件调用上述栈的操作

#include<stdio.h>
#include"stack.h"//记录了栈的表示以及栈相应操作的函数声明

int main(){
    //栈
    stack_t sk;
    //栈的初始化
    stack_init(5,&sk);
    //压栈 1 2 3 4 5
    int data = 1;
    while(stack_full(&sk) != 1){
         stack_push(&sk,data++);
    }
    //弹栈
    while(stack_empty(&sk) != 1){
        printf("%d ",stack_pop(&sk));
        }
    printf("\n");
    //释放
    stack_deinit(&sk);
        return 0;
}

队列

什么是队列

• 队列也是一种数据结构,队列也可以用来存放数字
• 每次只能向队列里加入一个数字，每次只能从队列里获得一个数字
• 在队列中，允许插入的一端称为队尾，允许删除的一端称为队头。
• 它按照先进先出(FIFO)的原则存储数据，先进入队列的数据先出队列。类似于火车过山洞，车头最先进入山洞，也是最先出山洞。
• 编写队列的时候也需要提供一个函数用来向队列里加入数字，还要提供一个函数用来从队列里获得数字

队列的表示

//队列
typedef struct queue{
    int* arr;//记录存储区的首地址
    int size;//有效元素个数
    int cap;//容量
    int front;//记录出队元素下标
    int rear;//记录入队元素下标
}queue_t;

队列的操作

• 队列的插入操作，称为入队。
• 队列的删除操作，称为出队。
• 

队列的初始化

//队列的初始化
//queue_t q;
//queue_init(&q,5);
void queue_init(queue_t* q,int cap){
    q->arr = malloc(sizeof(int) * cap);
    q->size = 0;
    q->cap = cap;
    q->front = 0;
    q->rear = 0;
}

队列的释放

//队列的释放
void queue_deinit(queue_t* q){
    free(q->arr);
    q->arr = NULL;
    q->size = 0;
    q->cap = 0;
    q->front = 0;
    q->rear = 0;
}

队列判满

//队列判满 满１　非满０
int queue_full(queue_t* q){
    if(q->size == q->cap){
        return 1;
    }else{
        return 0;
    }
}

队列判空

//队列判空　空１　非空０
int queue_empty(queue_t* q){
    if(q->size == 0){
        return 1;
    }else{
        return 0;
    }
}

入队

//入队 (*q).size = q->size
void queue_push(queue_t* q,int data){
    if(!queue_full(q)){
        q->arr[q->rear] = data;
        q->rear = (q->rear + 1) % q->cap;
        q->size++;
    }else{
       fprintf(stderr,"队列已满");
    }
}

出队

//出队
int queue_pop(queue_t* q){
    if(!queue_empty(q)){
        int data = q->arr[q->front];
        q->front = (q->front + 1) % q->cap;
        q->size--;
        return data;
    }else{
       fprintf(stderr,"队列为空");
    }
}

//队列的实现
#include<stdio.h>
#include<stdlib.h>
#include"queue.h"//记录了队列的表示以及队列相应操作的函数声明

//队列的初始化
//queue_t q;
//queue_init(&q,5);
void queue_init(queue_t* q,int cap){
    q->arr = malloc(sizeof(int) * cap);
    q->size = 0;
    q->cap = cap;
    q->front = 0;
    q->rear = 0;
}
//队列的释放
void queue_deinit(queue_t* q){
    free(q->arr);
    q->arr = NULL;
    q->size = 0;
    q->cap = 0;
    q->front = 0;
    q->rear = 0;
}
//队列判满 满１　非满０
int queue_full(queue_t* q){
    if(q->size == q->cap){
        return 1;
    }else{
        return 0;
    }
}
//队列判空　空１　非空０
int queue_empty(queue_t* q){
    if(q->size == 0){
        return 1;
    }else{
        return 0;
    }
}
//入队 (*q).size = q->size
void queue_push(queue_t* q,int data){
    if(!queue_full(q)){
        q->arr[q->rear] = data;
        q->rear = (q->rear + 1) % q->cap;
        q->size++;
    }else{
       fprintf(stderr,"队列已满");
    }
}
//出队
int queue_pop(queue_t* q){
    if(!queue_empty(q)){
        int data = q->arr[q->front];
        q->front = (q->front + 1) % q->cap;
        q->size--;
        return data;
    }else{
       fprintf(stderr,"队列为空");
    }
}