自学出现的问题：

                         1.不明白需要定义栈需要什么（定义两个指针，一个栈顶，一个栈尾，定义栈中元素个数）（定义一个的指针，加个数组）

                         2. 怎么给栈分配空间，或者说 malloc谁（是栈中元素，还是栈本身）

真正开始学习：

前戏：

void f(int m){
    int i;
    double *q = (double *)malloc(sizeof(double));
}
int main()
{
    int k;
    nt *p = (int *)malloc(100);
    return 0;
}

其中， m, i, k ,p为静态分配------栈区分配----操作系统分配

           100为动态分配------堆区分配------程序员手动分配

什么是栈？

                一种可以实现 先进后出 的存储结构

栈的分类：

               静态栈：以数组为基本内核

               动态栈：以链表为基本内核

栈的算法：

               出栈

               入栈

/*
动态栈
2021/10/8
刘小晴
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <malloc.h>

#define STACK_INIT_SIZE 10 //初始空间分配量
#define STACK_INCREMENT 2 //存储空间分配增量

typedef struct Node{
    int data;
    struct Node*pNext;
}NODE, *PNODE;

typedef struct Stack{
    PNODE pTop;
    PNODE pBottom;
}STACK, *PSTACK;


//init函数，使pTop, pBottom都指向头结点，造出一个空栈出来
void init(PSTACK pS){
    pS->pTop = (PNODE)malloc(sizeof(NODE));
    if(NULL == pS->pTop){
        printf("内存分配失败\n");
        exit(-1);
    }
    else{
        pS->pBottom = pS->pTop;
        pS->pTop->pNext = NULL;
    }
}

void push(PSTACK pS, int val){

    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    pNew->data = val;
    pNew->pNext = pS->pTop;
    pS->pTop = pNew;
}

bool empty(PSTACK pS){
    if(pS->pTop == pS->pBottom)
        return true;
    else
        return false;
}

//把pS所指向的栈的栈顶元素存入pVal所指向的变量中
bool pop(PSTACK pS, int *pVal){
    if(empty(pS)){
        printf("栈为空\n");
    }
    else{
        PNODE p = pS->pTop;
        *pVal = p->data;
        pS->pTop = p->pNext;
       free(p);
       p = NULL;

       return true;
    }

}

void traverse(PSTACK pS){
    NODE *p = pS->pTop;
    while(p != pS->pBottom){
        printf("%d\n", p->data);
        p = p->pNext;
    }
}
int main()
{
    STACK S;
    int p;
    init(&S);
    push(&S, 1);
    push(&S, 2);
    push(&S, 3);
    traverse(&S);
    pop(&S, &p);

    traverse(&S);
    printf("%d", p);

    return 0;
}