栈（建立，销毁，判空，判满及入栈和出栈）

栈的基本概念：

逻辑线性结构，堆栈可以用数组实现，也可以用链表实现，堆栈的概念只是一个逻辑结构，而实现是物理结构。

特点：

1：单端入数据；

2：先进后出

代码实现如下：

.h代码如下：

#ifndef _MEC_STACK_H_
#define _MEC_STACK_H_

#include "mec.h"

typedef struct MEC_STACK {
    void **stack;                　　　　 //定义一个类型是void **的名字为stack的数组，数组里面的元素的类型是void *；
    int capacity;                　　　　//定义一个栈的容量表示；
    int top;                   　　　　　　 //定义一个栈顶指针；
}MEC_STACK;

void initializeMecStack(MEC_STACK **head, int capacity);　　　　　　  //创建一个栈；*head以后可以更改主函数的值；
void destoryMecStack(MEC_STACK **head);                       　　　　　　 //销毁一个栈；
boolean isMecStackEmpty(const MEC_STACK stackCtrl);        　　　　　 //判断栈是否为空栈；
boolean isMecStackFull(const MEC_STACK stackCtrl);           　　　　　　 //判断栈是否已栈满；
boolean push(MEC_STACK *head, void *value);                   　　　　　　　//进行入栈操作；
void *pop(MEC_STACK *head);                                  　　　　　　　　 //进行出栈操作；

#endif

.c代码如下：

#include <stdio.h>
#include <malloc.h>

#include "../include/mec_stack.h"
#include "../include/mec.h"

void initializeMecStack(MEC_STACK **head, int capacity) {         //定义一个无返回值类型的创建栈的函数，有两个形参，分别是控制头的首地址和栈的容量 
    if(NULL == head || NULL != *head || capacity <= 0) {                    //判断是否有控制头有就返回了还有判断容量是否大于0；
        return;
    }
    *head = (MEC_STACK *) calloc(sizeof(MEC_STACK));        //申请一个类型为 MEC_STACK *的控制头；
    (*head)->capacity = capacity;                              //让*head指向的空间的capacity等于形参capaciy；
    (*head)->top = 0;                                                 //让*head指向的空间的top值为零；
    (*head)->stack = (void **) calloc(sizeof(void *), capacity);     //申请一个真正的堆栈空间stack；
}

void destoryMecStack(MEC_STACK **head) {         //定义一个无返回值类型的销毁栈的函数，只需要需要控制头的首地址即 MEC_STACK **head
    if(NULL == head || NULL == *head) {
        return;
    }
    free((*head)->stack);             //先释放堆栈空间；
    free(*head);                    //再释放控制头的空间；
    *head = NULL;                    
}

boolean isMecStackEmpty(const MEC_STACK stackCtrl) {
    return 0 == stackCtrl.top;          //判断栈空；stackCtrl相当于head所指向的空间；
}
 
boolean isMecStackFull(const MEC_STACK stackCtrl) {   //判断栈满；
    return stackCtrl.top >= stackCtrl.capacity;
}

boolean push(MEC_STACK *head, void *value) {                //入栈；把value放进去类型为void*；
    if(NULL == head || NULL == value || isMecStackFull(*head)) {
        return FALSE;
    }
    
    head->stack[head->top++] = value;            //先赋值top再加1；  
    
    return TRUE;
}

void *pop(MEC_STACK *head) {                       //出栈；
    if(NULL == head || isMecStackEmpty(*head)) {
        return NULL;
    }
    
    return head->stack[--head->top];            //先top-1再赋值；
}
void *read_Top(MEC_STACK  stackCtrl){     //读取栈顶元素的值；
    if( isMecStackEmpty(stackCtrl)){
        return NULL;
    }
    return stackCtrl.stack[stackCtrl.top - 1] ;
}