栈的实现

栈的定义：

栈是限制在表的一端进行插入和删除的线性表。允许插入、删除的这一端称为栈顶，另一个固定端称为栈底。当表中没有元素时称为空栈。

栈的操作：

1.创建栈

2.销毁栈

3.清空栈

4.进栈

5.出栈

6.获取栈顶元素

7.获取栈的大小

栈的实现方式：

1.顺序存储实现：利用数组，只对a[0]进行操作 。下面通过复用顺序链表代码实现。

2链式栈。

顺序栈的实现

SeqStack.h文件：

分析栈的功能需实现以下函数

#ifndef _SEQSTACK_H_
#define _SEQSTACK_H_

typedef void SeqStack;

SeqStack* SeqStack_Create();

void SeqStack_Clear();

void SeqStack_Destroy();

int SeqStack_Push(SeqStack* stack,void* item);

void* SeqStack_Pop(SeqStack* stack);

void* SeqStack_Top(SeqStack* stack);

int SeqStack_Size(SeqStack* stack);

#endif

SeqStack.c文件

#include "SeqList.h"
#include "SeqStack.h"

SeqStack* SeqStack_Create(int capacity)
{
	return SeqList_Create(capacity);
}

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

void SeqStack_Destroy(SeqStack* stack)
{
	return SeqList_Destroy(stack);
}

int SeqStack_Push(SeqStack* stack,void* item)
{
	return SeqList_Insert(stack, item, SeqList_Length(stack));
}

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

int SeqStack_Capacity(SeqStack* stack)
{
	return SeqList_Capacity(stack);
}

借助顺序表的文件（1）

SeqList.h文件

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif

借助顺序表的文件（2）

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

测试文件main.c

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

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[]) 
{
	SeqStack* stack =  SeqStack_Create(20);
	int a[10];
	int i=0;
	
	for(i=0;i<10;i++)
	{
		a[i] = i+1;	
		
		SeqStack_Push(stack,a+i);
	}
	
	printf("%d\n",*(int*)SeqStack_Top(stack));
	
	while( SeqStack_Size(stack) > 0 )
	{
		printf("Pop : %d\n",*(int*)SeqStack_Pop(stack));	
	}
	
	SeqStack_Destroy(stack);

	return 0;
}

链式栈的实现

LinkStack.h文件

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_

typedef void LinkStack;

LinkStack* LinkStack_Create();

void LinkStack_Clear(LinkStack* stack);

void LinkStack_Destroy(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

LinkStac.c文件

#include "LinkList.h"
#include "LinkStack.h"
#include <malloc.h>
typedef struct _tag_LinkStackNode
{
	LinkListNode* header;
	void* item;
}TLinkStackNode;

LinkStack* LinkStack_Create()
{
	return LinkList_Create();
}

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

void LinkStack_Destroy(LinkStack* stack)
{
	LinkStack_Clear(stack);
	LinkList_Destroy(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);
}

复用文件LinkList.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

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

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

int LinkList_Length(LinkList* list);

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

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

void LinkList_Clear(LinkList* list);

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

#endif

复用文件LinkList.c

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

typedef struct _tag_LinkList
{
	LinkListNode header;
	int length;
}TLinkList;

LinkList* LinkList_Create()
{
	TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));
	
	if( ret )
	{
		ret->header.next = NULL;
		ret->length = 0;	
	}
	
	return ret;	
}

void LinkList_Destroy(LinkList* list)
{
	free(list);
}

void LinkList_Clear(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;
	
	if( sList != NULL)
	{
		sList->header.next = NULL;
		sList->length = 0;	
	}	
}

int LinkList_Length(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;
	int ret = -1;
	
	if( sList != NULL)
	{
		ret = sList->length;	
	}		
	
	return ret;
}

LinkListNode* LinkList_Delete(LinkList* list,int pos)
{
	TLinkList* sList = (TLinkList*)list;
	LinkListNode* ret = NULL;
	int i = 0;	
	
	if( (sList != NULL) && (pos >= 0) && (pos < sList->length) )
	{
		LinkListNode* current = (LinkListNode*)sList;
		
		for(i=0;i<pos;i++)
		{
			current = current->next;	
		}	
		
		ret = current->next;
		current->next = ret->next;
		
		sList->length--;
	}
	
	return ret;	
}

int LinkList_Insert(LinkList* list,LinkListNode* node,int pos)
{
	TLinkList* sList = (TLinkList*)list;
	int ret = ((sList != NULL) && (pos >= 0) && (node != NULL));
	int i = 0;
	
	if( ret )
	{
		LinkListNode* current = (LinkListNode*)sList;
		
		for(i=0;(i<pos)&&(current->next != NULL);i++)
		{
			current = current->next;	
		}	
		
		node->next = current->next;
		current->next = node;
		
		sList->length++; 
	}		
	
	return ret;
}

LinkListNode* LinkList_Get(LinkList* list,int pos)
{
	TLinkList* sList = (TLinkList*)list;
	LinkListNode* ret = NULL;
	int i = 0;	
	
	if( (sList != NULL) && (pos >= 0) && (pos < sList->length) )
	{
		LinkListNode* current = (LinkListNode*)sList;
		
		for(i=0;i<pos;i++)
		{
			current = current->next;	
		}	
		
		ret = current->next;
	}
	
	return ret;
}

测试文件main.c

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

int main(int argc, char *argv[]) 
{
	LinkStack* stack =  LinkStack_Create();
	int a[10];
	int i=0;
	
	for(i=0;i<10;i++)
	{
		a[i] = i+1;	
		
		LinkStack_Push(stack,a+i);
	}
	
	printf("Top : %d\n",*(int*)LinkStack_Top(stack));
	
	while( LinkStack_Size(stack) > 0 )
	{
		printf("Pop : %d\n",*(int*)LinkStack_Pop(stack));	
	}
	
	LinkStack_Destroy(stack);
	return 0;
}

这就是栈的实现。