数据结构（二）---基本的栈的操作

栈的基本操作

在这周自己学了一下简单的栈的基本操作，对栈有了个基本的了解，就比如说，在程序里内存分为静态内存和动态内存，这两者的区别是，静态内存是放在栈里的，由系统分配内存的；动态内存是存放在堆里，由程序员手动给的。

栈的本质来讲这是一种存储方式，像是一个“先进后出的箱子”，把数据存放进去，如图

一个bottom一直指这个箱子的最下面的元素（最先放进去的）
一个top一直指着这个箱子的最上面的元素（最后放进去的）
里面的元素是用链表连在一起的
注意：栈里面最下面的那个元素不放东西，就类似于头节点

创建数据结构

//这个是数据的数据结构
typedef struct Node{
    int data;
    struct Node *next;
}NODE,*PNODE;


//这个是栈的数据结构
typedef struct Stack{
    PNODE pTop;  //栈头 
    PNODE pBottom; //栈底 
}STACK,*PSTACK; 

初始化栈

就是一开始先定义栈的结构的实例，然后用pBottom和pTop都先指向NULL

void init(PSTACK ps){
    ps->pTop = (PNODE)malloc(sizeof(NODE));
    if(ps->pTop ==NULL){
        printf("动态分配失败\n");
        exit(-1); 
    }else{
        ps->pBottom = ps->pTop;
        ps->pTop->next = NULL;
    }
}

压栈

void push(PSTACK ps,int val){
    PNODE pNew = (PNODE)malloc(sizeof(NODE));

    pNew->data = val;
    pNew->next = ps->pTop;
    ps->pTop = pNew;
}

出栈

这个出栈的时候，先判断是否为空，然后把栈顶的节点释放了，用一个值把它记载下来

bool pop(PSTACK ps,int *pval){
    if(empty(ps)){
        return false;
    }else{
        PNODE r = ps->pTop;
        *pval = r->data;
        ps->pTop = r->next;
        free(r);
        r = NULL;
        return true;
    }
} 

遍历

不断从栈顶往下遍历

void traverse(PSTACK ps){
    PNODE p = ps->pTop;
    while(p!=ps->pBottom){
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
}

判断是否为空

当pBottom和pTop相等的时候，就为空

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

清空

把里面的所以节点释放掉
先判断是否为空，为空的话，就不用清空了哈

void clear(PSTACK ps){
    if(empty(ps)){
        return;
    } else{
        PNODE p = ps->pTop;
        PNODE q = p->next;

        while(p!=ps->pBottom){
            q = p->next;
            free(p);
            p = q;
        }
        ps->pTop = ps->pBottom;
    }
} 

总的代码

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef struct Node{
    int data;
    struct Node *next;
}NODE,*PNODE;

typedef struct Stack{
    PNODE pTop;  //栈头 
    PNODE pBottom; //栈底 
}STACK,*PSTACK; 

void init(PSTACK);  //初始化栈 
void push(PSTACK,int); //压栈 
void traverse(PSTACK);  //遍历
bool pop(PSTACK ps,int *pval); //出栈
bool empty(PSTACK);
void clear(PSTACK);

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

bool pop(PSTACK ps,int *pval){
    if(empty(ps)){
        return false;
    }else{
        PNODE r = ps->pTop;
        *pval = r->data;
        ps->pTop = r->next;
        free(r);
        r = NULL;
        return true;
    }
} 
void init(PSTACK ps){
    ps->pTop = (PNODE)malloc(sizeof(NODE));
    if(ps->pTop ==NULL){
        printf("动态分配失败\n");
        exit(-1); 
    }else{
        ps->pBottom = ps->pTop;
        ps->pTop->next = NULL;
    }
}

void push(PSTACK ps,int val){
    PNODE pNew = (PNODE)malloc(sizeof(NODE));

    pNew->data = val;
    pNew->next = ps->pTop;
    ps->pTop = pNew;
}

void traverse(PSTACK ps){
    PNODE p = ps->pTop;
    while(p!=ps->pBottom){
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
}
void clear(PSTACK ps){
    if(empty(ps)){
        return;
    } else{
        PNODE p = ps->pTop;
        PNODE q = p->next;

        while(p!=ps->pBottom){
            q = p->next;
            free(p);
            p = q;
        }
        ps->pTop = ps->pBottom;
    }
} 
int main(void){
    STACK s;
    int val;
    init(&s);
    push(&s,1);
    push(&s,2);
    push(&s,3);
    if(pop(&s,&val))
    {
        printf("出栈元素是%d\n",val);
    } else{
        printf("失败\n"); 
    }
    traverse(&s); 
    clear(&s);
    traverse(&s); 
    return 0;
} 

总结

在数据结构的中栈是很重要的一部分，比如函数调用，中断， 表达式求值， 内存分配， 缓冲处理， 迷宫 等问题上都会用到栈，这篇博客只是简单讲下基本栈的操作，以后会继续研究的哈。