链式栈

链式栈

1.基本概念

2.设计和实现

• 头文件

#ifndef _MY_LINKSTACK_H_
#define _MY_LINKSTACK_H_

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include "TLinkList.h"
typedef void LinkStack;//数据类型封装--栈起始位置

/*这样封装的目的是简化上层数据模型的封装，
只需提供要操作的数据对象的起始地址即可
同理可以像单向链表一样同一个栈中存放
不同数据类型的节点的信息（主要是数据对象起始位置）*/
typedef struct _tagMyStruct
{
    LinkListNode node;//栈里面元素的指针域--用来指明元素之间位置关系
    void * item;//栈里面元素的数据域--栈的业务节点
                //这个数据域也是一个指针--指向实际要入栈的数据对象的起始位置

}LinkStackNode;//数据类型封装--单向链表的业务节点

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);

#endif //_MY_LINKSTACK_H_

• 实现文件

#include "linkstack.h"
#include "TLinkList.h"



/*创建*/
LinkStack* LinkStack_Create()
{
    /*直接调用链表的创建函数返回栈/链表的句柄（都是void*做封装）*/
    return (LinkStack*)LinkList_Create();
}


/*销毁--由于栈的业务节点包裹在链表的业务节点里面，涉及到内存回收*/
void LinkStack_Destroy(LinkStack* stack)
{
    /*合法性*/
    if (stack == NULL)
    {
        printf("argv error!\n");
        return;
    }

    /*栈的清空函数会将所有元素弹出栈并回收为每一个节点分配的内存*/
    LinkStack_Clear(stack);

    /*回收表头结点的内存--链表表头结点也在堆开辟了内存*/
    free(stack);

    return ;
}

/*清空*/
void LinkStack_Clear(LinkStack* stack)
{
    if (stack == NULL)
    {
        printf("argv error!\n");
        return;
    }

    /*根据栈的长度逐个弹出栈顶元素直到栈为空*/
    while (LinkStack_Size(stack) > 0)
    {
        LinkStack_Pop(stack);
    }

    return ;
}

/*压栈--将栈的业务节点包裹到链表的业务节点里面
  得到的链表业务节点才可以直接给链表的API使用
*/
int LinkStack_Push(LinkStack* stack, void* item)
{
    LinkStackNode * tmp = NULL;
    int ret = 0;

    /*构造适合链表API使用的链表业务节点*/
    tmp = (LinkStackNode *)malloc(sizeof(LinkStackNode));
    if (tmp == NULL)
    {
        return -1;
    }

    /*初始化当前链表业务节点*/
    memset(tmp, 0, sizeof(LinkStackNode));

    /*将要入栈的数据对象包裹到上述的链表业务节点，以便插入链表*/
    tmp->item = item;

    /*插入链表节点*/
    ret =  LinkList_Insert((LinkList*)stack, (LinkListNode*)tmp, 0);

    if (ret != 0)//插入失败
    {
        printf("LinkList_Insert failed!\n");
        free(tmp);//立即回收内存
    }

    return ret;
}

/*出栈*/
void* LinkStack_Pop(LinkStack* stack)
{
    LinkStackNode * tmp = NULL;
    void * item = NULL;

    /*从链表中删除要出栈的元素所在的链表节点--返回的是链表业务节点*/
    tmp = (LinkStackNode*)LinkList_Delete((LinkList*)stack, 0);
    if (tmp == NULL)//删除失败
    {
        printf("fail!\n");
        return NULL;
    }

    /*提取链表节点里面的栈的数据对象的起始位置，并缓存*/
    item =  tmp->item;

    /*回收当前出栈的链表业务节点--
    此时还有一个辅助变量指向栈节点对应的数据对象（起始位置）*/
    free(tmp);

    /*返回单纯的栈业务节点--数据对象的起始位置*/
    return item;
}


/*获取栈顶元素*/
void* LinkStack_Top(LinkStack* stack)
{
    LinkStackNode * tmp = NULL;

    /*从链表中获取栈顶/链表头的链表节点*/
    tmp = (LinkStackNode*)LinkList_Get((LinkList*)stack, 0);
    if (tmp == NULL)//获取失败
    {
        printf("Top failed!\n");
        return NULL;
    }

    /*从链表节点中提取栈节点并返回*/
    return tmp->item;
}


/*获取元素个数*/
int LinkStack_Size(LinkStack* stack)
{
    /*栈的节点个数保存在链表表头的length数据域
    直接调用链表长度函数即可*/
    return LinkList_Length((LinkList*)stack);
}

• 测试文件

#include "linkstack.h"

int main()
{
    LinkStack * stack = NULL;
    int a[10];
    int i = 0;

    stack = LinkStack_Create();
    if (stack == NULL)
    {
        printf("create error\n");
        return -1;
    }

    for (i = 0; i < 5;i++)
    {
        a[i] = i + 1;
        LinkStack_Push(stack, (void*)&a[i]);
    }

    printf("Length : %d\n", LinkStack_Size(stack));
    printf("Top : %d\n", *((int *)LinkStack_Top(stack)));

    while (LinkStack_Size(stack) > 0)
    {
        printf("Pop: %d\n", *((int *)LinkStack_Pop(stack)));
    }

    LinkStack_Destroy(stack);

    system("pause");
    return 0;
}