数据结构 06 栈 实现

#include <malloc.h>
#include "linkstack.h"
#include "LinkList.h"

typedef struct _tag_LinkStackNode
{
LinkListNode header;
void* item;
}TLinkStackNode;

LinkStack* LinkStack_Create()
{
return LinkList_Create();
}
void LinkStack_Destroy(LinkStack* stack)
{
LinkStack_Clear(stack);//由于每个结点都分配了 内存malloc所以需要先释放结点内存
LinkList_Destroy(stack);
}

void LinkStack_Clear(LinkStack* stack)
{
while( LinkStack_Size(stack) > 0)
{
LinkStack_Pop(stack);
}
}

int LinkStack_Push(LinkStack* stack, void* item)
{
TLinkStackNode* node = (TLinkStackNode*)malloc(sizeof(TLinkStackNode));
int ret = (node != NULL) && (item != NULL);

if(ret)
{
node->item = item;

ret = LinkList_Insert(stack, (LinkListNode*)node, 0);
}

if(!ret)
{
free(node);
}
return ret;
}

void* LinkStack_Pop(LinkStack* stack)
{
TLinkStackNode* node = (TLinkStackNode*)LinkList_Delete(stack, 0);
void* ret = NULL;

if(node != NULL)
{
ret = node->item;
free(node);
}
return ret;
}

void* LinkStack_Top(LinkStack* stack)
{
TLinkStackNode* node = (TLinkStackNode*)LinkList_Get(stack, 0);
void* ret = NULL;

if(node != NULL)
{
ret = node->item;
}
return ret;
}

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

#include "seqstack.h"
#include "SeqList.h"

SeqStack* SeqStack_Create(int size)
{
return SeqList_Create(size);//返回值是void型的typedef仅仅是一个别名
}

void SeqStack_Deatroy(SeqStack* stack)
{
SeqList_Destroy(stack);
}

void SeqStack_Clear(SeqStack* stack)
{
SeqList_Clear(stack);
}

int SeqStack_Push(SeqStack* stack, void* item)
{
return SeqList_Insert(stack, item, SeqList_Length(stack));//放到了队尾
}

//Pop出栈 返回栈顶元素并且将它输出
void* SeqStack_Pop(SeqStack* stack)
{
return SeqList_Delete(stack, SeqList_Length(stack) - 1);
}

void* SeqStack_Top(SeqStack* stack)
{
return SeqList_Get(stack, SeqList_Length(stack) - 1);
}

int SeqStack_Size(SeqStack* stack)
{
return SeqList_Length(stack);
}

// SeqList.c
#include <stdio.h>
#include <malloc.h>
#include "SeqList.h"

typedef unsigned int TSeqListNode;

typedef struct _tag_SeqList
{
int capacity;
int length;
TSeqListNode* node;
} TSeqList;

SeqList* SeqList_Create(int capacity) // O(1)
{
TSeqList* ret = NULL;

if( capacity >= 0 )
{
ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode) * capacity);
}

if( ret != NULL )
{
ret->capacity = capacity;
ret->length = 0;
ret->node = (TSeqListNode*)(ret + 1);
}

return ret;
}

void SeqList_Destroy(SeqList* list) // O(1)
{
free(list);
}

void SeqList_Clear(SeqList* list) // O(1)
{
TSeqList* sList = (TSeqList*)list;

if( sList != NULL )
{
sList->length = 0;
}
}

int SeqList_Length(SeqList* list) // O(1)
{
TSeqList* sList = (TSeqList*)list;
int ret = -1;

if( sList != NULL )
{
ret = sList->length;
}

return ret;
}

int SeqList_Capacity(SeqList* list) // O(1)
{
TSeqList* sList = (TSeqList*)list;
int ret = -1;

if( sList != NULL )
{
ret = sList->capacity;
}

return ret;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // O(n)
{
TSeqList* sList = (TSeqList*)list;
int ret = (sList != NULL);
int i = 0;

ret = ret && (sList->length + 1 <= sList->capacity);
ret = ret && (0 <= pos);

if( ret )
{
if( pos >= sList->length )
{
pos = sList->length;
}

for(i=sList->length; i>pos; i--)
{
sList->node[i] = sList->node[i-1];
}

sList->node[i] = (TSeqListNode)node; // ÕâÀïÖ±½Ó½«Ö¸Õëת»»³ÉÁËunsigned int ¶øûÓÐʹÓöþ¼¶Ö¸Õë

sList->length++;
}

return ret;
}

SeqListNode* SeqList_Get(SeqList* list, int pos) // O(1)
{
TSeqList* sList = (TSeqList*)list;
SeqListNode* ret = NULL;

if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
{
ret = (SeqListNode*)(sList->node[pos]);
}

return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos) // O(n)
{
TSeqList* sList = (TSeqList*)list;
SeqListNode* ret = SeqList_Get(list, pos);
int i = 0;

if( ret != NULL )
{
for(i=pos+1; i<sList->length; i++)
{
sList->node[i-1] = sList->node[i];
}

sList->length--;
}

return ret;
}

#include <stdio.h>
#include <stdlib.h>
#include "seqstack.h"

int main(void)
{
SeqStack* stack = SeqStack_Create(20);
int a[10];
int i = 0;
for(; i<10; ++i)
{
a[i] = i;
SeqStack_Push(stack, a + i);
}
printf("top is %d\n", *(int*)SeqStack_Top(stack));//Ïëת»»³Éint*ÐÍÔÙ È¡ÀïÃæµØÖ·±£³ÖµÄÔªËØ
printf("size is %d\n", SeqStack_Size(stack));

while( SeqStack_Size(stack) > 0)
{
printf("pop is %d\n", *(int*)SeqStack_Pop(stack));//Pop³öÕ» ·µ»ØÕ»¶¥ÔªËز¢ÇÒ½«ËüÊä³ö
}

SeqStack_Deatroy(stack);

return 0;
}