带头节点的不带环的单向链式栈的基本操作

完成链式栈 
1.初始化
2.销毁
3.入栈
4.出栈

5.取栈顶元素

    

如果LinkStack stack定义的stack是在栈上的，那么它结构体里面的head也是在栈上的；但如果stack是malloc出来的，像这样（LinkStack* stack=malloc( )），那head变量就在堆上。head究竟是在栈上还是堆上，得看它所属的具体在哪。

seqstack.h

//单向带头结点的不带环的单向链式表的头插头删。head位置就是栈顶，尾部是栈底。
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stddef.h>
typedef char LinkStackType;
typedef struct LinkNode{
LinkStackType data;
struct LinkNode* next;
}LinkNode;
typedef struct LinkStack{
LinkNode head;
}LinkStack;
void LinkStackInit(LinkStack* stack);//初始化函数
void DestroyNode(LinkNode* node);//销毁函数
void LinkStackPrintChar(LinkStack* stack, const char* msg);//打印函数
void LinkStackPush(LinkStack* stack, LinkStackType value);//入栈
void LinkStackPop(LinkStack* stack);//出栈

int LinkStackTop(LinkStack* stack, LinkStackType* value);//取栈顶元素

linkstack.c

#include "linkstack.h"
void LinkStackInit(LinkStack* stack){//初始化函数
if (stack == NULL){
//非法输入
return;
}
stack->head.data = '\0';//.用于结构体指向的内容，->用于指针指向的内容，'\0'让它随便指向一个数。data也可以不用赋值，不用的时候它被视为无效的元素
stack->head.next = NULL;
}
void LinkStackPrintChar(LinkStack* stack, const char* msg){//销毁函数
printf("[%s]\n", msg);
printf("栈顶  ");
LinkNode* cur = stack->head.next;
for (; cur != NULL; cur = cur->next){
printf("[%c|%p]   ", cur->data, cur);
}
printf("  栈底");
}
LinkNode* CreateNode(LinkStackType value){
LinkNode* newnode = (LinkNode*)malloc(sizeof(LinkNode));
newnode->data = value;
newnode->next = NULL;
return newnode;
}
void DestroyNode(LinkNode* node){//销毁函数
free(node);
}
void LinkStackPush(LinkStack* stack, LinkStackType value){//入栈
if (stack == NULL){
//非法输入
return;
}
LinkNode* newnode = CreateNode(value);
newnode->next = stack->head.next;
stack->head.next = newnode;
}
void LinkStackPop(LinkStack* stack){//出栈。栈后进先出
if (stack == NULL){
//非法输入
return;
}
LinkNode* to_delete = stack->head.next;
stack->head.next = to_delete->next;
DestroyNode(to_delete);
}
int LinkStackTop(LinkStack* stack, LinkStackType* value){//取栈顶元素
if (stack == NULL||value == NULL){
//非法输入
return 0;
}
if (stack->head.next == 0){
//空栈
return 0;
}
*value = stack->head.next->data;
return 1;

}

test.c

#include "linkstack.h"
#define TEST_HEADER printf("\n==================%s==================\n",__FUNCTION__);
void TestInit(){
TEST_HEADER;
LinkStack stack;
LinkStackInit(&stack);
LinkStackPrintChar(&stack,"初始化空栈");
}
void TestPush(){
TEST_HEADER;
LinkStack stack;
LinkStackInit(&stack);
LinkStackPush(&stack, 'a');
LinkStackPush(&stack, 'b');
LinkStackPush(&stack, 'c');
LinkStackPush(&stack, 'd');
LinkStackPrintChar(&stack, "入栈四个元素");
}
void TestPop(){
TEST_HEADER;
LinkStack stack;
LinkStackInit(&stack);
LinkStackPush(&stack, 'a');
LinkStackPush(&stack, 'b');
LinkStackPush(&stack, 'c');
LinkStackPush(&stack, 'd');
LinkStackPrintChar(&stack, "入栈四个元素");
LinkStackPop(&stack);
LinkStackPop(&stack);
LinkStackPrintChar(&stack, "出栈两个元素");


}
void TestTop(){
TEST_HEADER;
LinkStack stack;
LinkStackInit(&stack);
LinkStackPush(&stack, 'a');
LinkStackPush(&stack, 'b');
LinkStackPush(&stack, 'c');
LinkStackPush(&stack, 'd');
LinkStackPrintChar(&stack, "入栈四个元素");
printf("\n");
LinkStackType value;
int ret = LinkStackTop(&stack,&value);
printf("expect ret is 1,actual is %d\n", ret);
printf("expect ret is d,actual is %c\n", value);


LinkStackPop(&stack);
LinkStackPop(&stack);
ret = LinkStackTop(&stack,&value);
LinkStackPrintChar(&stack, "出栈两个元素");
printf("\n");
printf("expect ret is 1,actual is %d\n", ret);
printf("expect ret is b,actual is %c\n", value);
}
int main(){
TestInit();
TestPush();
TestPop();
TestTop();
getchar();
return 0;
}