C语言-栈tack顺序存储和链式存储

理解栈tack

栈也是一种特殊的线性表，栈的工作原理是先进后出，因此在对栈操作时只能在栈顶操作。栈的插入操作，叫作入栈（压栈），栈的删除操作，叫作出栈（弹栈）。

栈的顺序存储选择尾部压栈和弹栈时，不会涉及到数组元素的大量移动。

栈的链式存储选择在链表头部入栈和出栈时，减少了数组元素的大量移动

注意：在栈的链式存储中结点中涉及了指针变量，因此入栈的结点都需要malloc，在出栈时需要释放结点内存

stack栈的顺序存储

栈的顺序存储类似线性表的顺序存储

//SeqStack.h
#pragma once
typedef void SeqStack;
//创建栈
SeqStack* SeqStack_Create(int capacity);
//销毁栈
void SeqStack_Destroy(SeqStack* stack);
//清空栈
void SeqStack_Clear(SeqStack* stack);
//压栈
int SeqStack_Push(SeqStack* stack, void* item);
//弹栈
void* SeqStack_Pop(SeqStack* stack);
//获取栈顶元素
void* SeqStack_Top(SeqStack* stack);
//获取栈的大小
int SeqStack_Size(SeqStack* stack);
//获取栈的容量
int SeqStack_Capacity(SeqStack* list);
           

stack栈的链式存储

//LinkStack.h
#pragma once
typedef void LinkStack;
//创建链栈
LinkStack* LinkStack_Create();
//销毁链栈
void LinkStack_Destroy(LinkStack* stack);
//清空链栈
void LinkStack_Clear(LinkStack* stack);
//压栈
int LinkStack_Push(LinkStack* stack, void* item);
//弹出
void* LinkStack_Pop(LinkStack* stack);
//获取栈顶元素
void* LinkStack_Top(LinkStack* stack);
//获取栈的大小
int LinkStack_Size(LinkStack* stack);
           

入栈出栈操作分析

入栈时需要为结点分配内存空间（链栈的结点包含了指向后继结点的指针域）。同样出栈时需要释放为结点分配的内存。

//LinkStack.c
#pragma warning(disable : 4996)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "LinkStack.h"
#include "LinkList.h"

//栈中的结点去包含链表结点
typedef struct tag_LinkStackNode
{
    TLinkListNode node;
    void* item;
}TLinkStackNode;
//创建链栈
LinkStack * LinkStack_Create()
{
    LinkStack* temp = (LinkStack*)LinkList_Creat();
    return temp;
}
//销毁栈
void LinkStack_Destroy(LinkStack* stack)
{
    LinkStack_Clear(stack);
    LinkList_Destroy((LinkList *)stack);
    return;
}
//清空栈
void LinkStack_Clear(LinkStack* stack)
{
    if (stack == NULL)
    {
        printf(" LinkStack_Clear err:stack = NULL");
        return;
	}
    //依次从栈顶弹出结点元素
    while (LinkStack_Size(stack) > 0)
    {
        LinkStack_Pop(stack);
    }
    return;
}
//入栈
int LinkStack_Push(LinkStack* stack, void* item)
{
    TLinkStackNode* temp = NULL;
    int ret = 0;
    if (stack == NULL || item == NULL)
    {
        printf(" LinkStack_Push err: stack = NULL || item = NULL");
        return -1;
    }
    temp = (TLinkStackNode *)malloc(sizeof(TLinkStackNode));//为结点分配内存
    if (temp == NULL)
    {
        return -2;
    }
    memset(temp, 0, sizeof(TLinkStackNode));//初始化结点
    temp->item = item;//保存结点数据
    ret = LinkList_inster(stack, (TLinkListNode*)temp, 0);//入栈
    if (ret != 0)
    {
        printf(" LinkList_inster err:%d\n", ret);
        if (temp != NULL)
        {
            free(temp);
        }
        return ret;
    }
    return ret;
}
//出栈
void * LinkStack_Pop(LinkStack* stack)
{
    TLinkStackNode* temp = NULL;
    void *item = NULL;
    if (stack == NULL)
    {
        printf(" LinkStack_Pop err:stack = NULL");
        return NULL;
    }
    temp = (TLinkStackNode *)LinkList_Delete(stack, 0);//删除栈顶元素，并返回结点
    if (temp != NULL)
    {
        item = temp->item;//获取结点数据
        free(temp);//释放结点
    }
    return item;//返回结点数据
}
//获取栈顶元素
void * LinkStack_Top(LinkStack* stack)
{
    TLinkStackNode* temp = NULL;
    if (stack == NULL)
    {
        printf(" LinkStack_Top err:stack = NULL");
        return NULL;
    }
    temp = (TLinkStackNode *)LinkList_Get(stack, 0);
    if (temp == NULL)
        return NULL;
    return temp->item;
}
//获取栈的大小
int LinkStack_Size(LinkStack* stack)
{
    if (stack == NULL)
    {
        printf(" LinkStack_Size err:stack = NULL");
        return -1;
    }
    return LinkList_GetLength(stack);
}