C 栈 链式存储

#ifndef _MY_LINKSTACK_H_
#define _MY_LINKSTACK_H_

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

#endif //_MY_LINKSTACK_H_

#define  _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "linkstack.h"
#include "linklist.h"

typedef struct _tag_LinkStack
{
    LinkListNode node;
    void* item;
}TLinkStack;

//创建一个栈 相当于 创建一个线性表
LinkStack* LinkStack_Create()
{
    return LinkList_Create();
}

void LinkStack_Destroy(LinkStack* stack)
{
    LinkStack_Clear(stack);  //释放栈的 结点
    LinkList_Destroy(stack);  //释放句柄
}

void LinkStack_Clear(LinkStack* stack)
{
    while (LinkList_Length(stack) > )
    {
        LinkStack_Pop(stack);
    }
    return ;
}

//向栈中添加元素 相等向 线性表中 添加结点
int LinkStack_Push(LinkStack* stack, void* item)
{
    int            ret = ;
    TLinkStack *tmp = NULL;

     //// void* item 栈结点  ===>链表结点
    tmp = (TLinkStack *)malloc(sizeof(TLinkStack));
    tmp->item = item;

    ret = LinkList_Insert(stack, (LinkListNode *)tmp, );
    if (ret != )
    {
        printf("func LinkList_Insert() err:%d \n", ret);
        free(tmp);
        return ret;
    }
    return ret;
}

//从栈中 弹出 元素   相当于 从线性表中 删除0号位置元素
void* LinkStack_Pop(LinkStack* stack)
{
    TLinkStack *tmp = NULL;

    void *item = NULL;

    tmp = (TLinkStack*) LinkList_Delete(stack, );
    if (tmp == NULL)
    {
        printf("func LinkList_Delete() err \n");
        return NULL;
    }
    //把链表节点 ====>转换成  栈结点
    item = tmp->item;

    free(tmp);

    return item;
}

//获取栈顶元素 相等于 从线性表的0号位置元素
void* LinkStack_Top(LinkStack* stack)
{
    TLinkStack *tmp = NULL;
    void *item = NULL;

    tmp = (TLinkStack *)LinkList_Get(stack, );
    if (tmp == NULL)
    {
        printf("func LinkStack_Top() err \n");
    }
    item = tmp->item;
    return item;
}

int LinkStack_Size(LinkStack* stack)
{
    return LinkList_Length(stack);
}

#ifndef _MYLINKLIST_H_
#define _MYLINKLIST_H_

typedef void LinkList;
/*
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{
    LinkListNode* next;
};
*/

typedef struct _tag_LinkListNode
{
    struct _tag_LinkListNode* next;
}LinkListNode;

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

LinkListNode* LinkList_Get(LinkList* list, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif

#define  _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "linklist.h"

typedef struct _tag_LinkList
{
    LinkListNode header;
    int        length;
}TLinkList;
//
LinkList* LinkList_Create()  //O(1)
{
    TLinkList *tmp = NULL;

    tmp = (TLinkList *)malloc(sizeof(TLinkList));
    if (tmp == NULL)
    {
        printf("func LinkList_Create() err \n");
        return NULL;
    }
    memset(tmp, , sizeof(TLinkList));
    tmp->length = ;
    tmp->header.next = NULL; //
    return tmp;
}

void LinkList_Destroy(LinkList* list)  //O(1)
{
    if (list == NULL)
    {
        return ;
    }
    free(list);
    return ;
}

void LinkList_Clear(LinkList* list)   //O(1)
{
    TLinkList *tList = NULL;
    tList = (TLinkList *)list;
    if (tList == NULL)
    {
        return ;
    }
    tList->header.next = NULL;
    tList->length = ;

    return ;
}

int LinkList_Length(LinkList* list)  //O(1)
{
    TLinkList *tList = NULL;
    tList = (TLinkList *)list;
    if (tList == NULL)
    {
        return -;
    }
    return tList->length;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)  //O(n)
{
    int                i = ;
    LinkListNode    *current = NULL;
    TLinkList        *tList = NULL;

    tList = (TLinkList *)list;

    if (list==NULL || node==NULL || pos<)
    {
        return -;
    }

    current = &(tList->header);
    for (i=; i<pos; i++)
    {
        current = current->next;
    }
    //新结点 连接 后继链表
    node->next = current->next;

    //前面的链表 连接 新结点
    current->next = node;

    tList->length ++;
    return ;
}

LinkListNode* LinkList_Get(LinkList* list, int pos)  //O(n)
{
    int                i = ;
    LinkListNode    *current = NULL;
    TLinkList        *tList = NULL;

    tList = (TLinkList *)list;

    if (list==NULL || pos<)
    {
        return NULL;
    }

    current = &(tList->header); //赋值指针变量初始化
    for (i=; i<pos; i++)
    {
        current = current->next;
    }
    return current->next;
}

LinkListNode* LinkList_Delete(LinkList* list, int pos) //O(n)
{
    int                i = ;
    LinkListNode    *current = NULL;
    LinkListNode    *ret = NULL;
    TLinkList        *tList = NULL;

    tList = (TLinkList *)list;
    if (list==NULL || pos<)
    {
        return NULL;
    }

    current = &(tList->header);
    for (i=; i<pos; i++)
    {
        current = current->next;
    }
    ret = current->next; //缓存要删除的结点

    current->next = ret->next;

    tList->length --;

    return ret;
}

#define  _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "linkstack.h"

void main()
{
    LinkStack *stack = NULL;
    int  a[], i = ;

    for (i=; i<; i++)
    {
        a[i] = i+;
    }

    stack = LinkStack_Create();

    //向栈中 添加 元素
    for (i=; i<; i++)
    {
        LinkStack_Push(stack, &a[i]); //抛砖: 栈的结点a[i]==>转换成(适配成) 链表结点 ===>插入到链表库
    }

    //栈的属性
    printf("len:%d \n", LinkStack_Size(stack));
    printf("top:%d \n",  *( (int *)LinkStack_Top(stack) )  );

    /*
    //元素 出栈
    while (LinkStack_Size(stack) > 0 )
    {
        int tmp = 0;
        tmp = *( (int *)LinkStack_Pop(stack) );
        printf("%d ", tmp);
    }
    */

    LinkStack_Destroy(stack);

    printf("hello...\n");
    system("pause");
    return ;
}