数据结构-栈

1、链表实现---》定义链表结点结构体，确定链表要存储的数据，也是栈元素要存储的数据。

2、栈实现----》定义栈结构体，保存栈顶和栈底。实现函数 

    1、create创建栈（定义栈结构体） 

    2、push压入元素，参数为要保存的值

    3、pop 弹出元素

    4、top 

    5、isEmpty

typedef struct node{
    int token;
    struct node* next;
}node;

typedef struct mystack{
    node* top;
}mystack;

mystack* createStack(){
    mystack* s = (mystack*)malloc(sizeof(mystack));
    s->top = NULL;
    return s;
}
bool isEmpty(mystack* s){
    return s->top == NULL;
}
void push(mystack* s,int token){
    node* n = (node*)malloc(sizeof(node));
    n->token = token;
    n->next = s->top;
    s->top = n;
}
void pop(mystack* s){
    if(!s->top) cout<<"Error"<<std::endl;
    s->top=s->top->next;
}

别人的

/* 
** 定义一个结构以存储堆栈元素。 
*/  
typedef struct STACK_NODE  
{  
    STACK_TYPE value;  
    struct STACK_NODE *next;  
} StackNode;  
  
/* 指向堆栈中第一个节点的指针 */  
static StackNode *stack;  
  
/* create_stack */  
void create_stack(size_t size)  
{}  
  
/* destroy_stack */  
void destroy_stack(void)  
{  
    while(!is_empty())  
        pop();  /* 逐个弹出元素，逐个释放节点内存 */  
}  
  
/* push */  
void push(STACK_TYPE value)  
{  
    StackNode *new_node;  
    new_node = (StackNode *)malloc(sizeof(StackNode));  
    if(new_node == NULL)  
        perror("malloc fail");  
    new_node->value = value;  
    new_node->next = stack;  /* 新元素插入链表头部 */  
    stack = new_node;       /* stack 重新指向链表头部 */  
}  
  
/* pop */  
void pop(void)  
{  
    StackNode *first_node;  
      
    assert(!is_empty());  
    first_node = stack;  
    stack = first_node->next;  
    free(first_node);  
}  
  
/* top */  
STACK_TYPE top(void)  
{  
    assert(!is_empty());  
    return stack->value;  
}  
  
/* is_empty */  
int is_empty(void)  
{  
    return stack == NULL;  
}  
  
/* is_full */  
int is_full(void)  
{  
    return FALSE;  
}  
  

差距在

1：栈不需要定义一个新的结构体，直接用结点指针就可以，在我的栈结构体中也只有一个元素就是top指针。

2：使用链表实现栈，在pop弹出元素时需要对申请的内存free，所有使用了malloc的代码，都需要使用到free。不然会出现内存泄露。