栈 链表综合使用

<span style="background-color: rgb(204, 204, 204);">#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <malloc.h>
#include<assert.h>

typedef struct Stack
{
    int nValue;
    struct Stack *pNext;
    
}Stack, *PStack;                                      //链表的定义 ，属于一个对象，一个对象包含一个值，和指向下一个对象的指针，就是指向下一个对象的地址，这个地址存储的是下一个对象

PStack CreateStack()
{
    PStack pStack = (PStack)malloc(sizeof(Stack));
    pStack->nValue = 0;
    pStack->pNext = NULL;
    
    return pStack;
}                                                                          //建立一个链表，首先开辟存储链表的空间，以及对象的成员函数，value和指针对象pNext,pNext指向的下一个
                                                                           //链表结点是空NULL，表示创建表头成立

bool IsEmpty(PStack pStack)
{
	if(NULL == pStack)
	{
		printf("栈未创建成功!\n");
	}
    return pStack->pNext == NULL;                                     //判断链表是不是空的，就是指表头指向的下一个对象是不是NULL，就是指向的对象是不是空对象
}
PStack PushStack(PStack pStack, int nValue)
{
	if(NULL == pStack)
	{
		printf("栈未创建成功!\n");
		return NULL;
	}                                                                      //首先判断链表是不是创建了，，就是链表头是不是空内存
    PStack pTmp = (PStack)malloc(sizeof(Stack));                          //首先给需要压入栈的对象开辟内存，用于存储value和pNext指针
    pTmp->nValue = nValue;                                               //因为是入栈式操作，在表头后面添加对象，对象的pNext指针指向的应该是表头指向的对象
    pTmp->pNext = pStack->pNext;                               
    pStack->pNext = pTmp;                                                //表头指向的是入栈的对象

    return pStack;
}

//这里每次都会删除链表中的一个结点 所以不用传递PStack *pStack；
int PopStack(PStack pStack)
{
	if(NULL == pStack)
	{
		printf("栈未创建成功!\n");
	}                             
    PStack pTmp = pStack->pNext;                                                  //出栈操作，是先进后出，则出栈，首先出的是表头指向的对象
    pStack->pNext = pTmp->pNext;                                                 //表头指向的对象出栈后，则表头指向，出栈对象的下一个对象
                                                                            
    int nValue = pTmp->nValue;
    free(pTmp);                                                                 //释放存储对象的内存

    return nValue;
}

void Destroy(PStack pStack)
{
    while (!IsEmpty(pStack))
    {
        PopStack(pStack);                          
    }
    free(pStack);
    pStack = NULL;                                               //释放表头，清空内存            
}
int main()
{
    PStack pStack = CreateStack();    //建立一个链表头head   只有值value和 pNext指针
    
    for (int i = 0; i < 10; i++)
    {
        pStack = PushStack(pStack, i);
    }                                                              //入栈的操作，因为指针指向的是地址，这个地址存储的是一个对象

    while (!IsEmpty(pStack))
    {
        printf("%d ", PopStack(pStack));                       //链表中的出栈操作
    }
    
    Destroy(pStack);
	system("pause");
    return 0;
}</span>