您的位置：首页 > 编程语言 > C语言/C++

栈的实现与操作(C语言实现)

2014-06-09 12:16 567 查看
栈的定义
1， 栈是一种特殊的线性表
2，栈仅能在线性表的一端进行操作
3，栈顶(Top)： 允许操作的一端 允许操作的一端
4，栈底(Bottom)： ,不允许操作的一端 不允许操作的一端

这里我做出了 栈的顺序实现 和 链式实现，分别如下：
=========================================华丽丽的分割线==========================================================
栈的顺序实现：
首先，我们要弄明白的是，栈本质上就是线性表，是一种特殊的线性表，只是只能在一端进行操作罢了，故而很多操作线性表是很类似的。因此，我们可以将之前写的  顺序线性表的实现及操作（C语言实现） 中的代码直接拿过来使用，以达到代码复用的效果（代码就不在此处追述了）。
头文件：

#ifndef _SEQSTACK_H_
#define _SEQSTACK_H_

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

#endif


源文件：


// 栈.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <malloc.h>
#include <stdlib.h>
#include "SeqStack.h"
#include "SeqList.h"

int _tmain(int argc, _TCHAR* argv[])
{
SeqStack* stack = SeqStack_Create(20);
int a[10];
int i = 0;

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

SeqStack_Push(stack, a + i);
}

printf("Top: %d\n", *(int*)SeqStack_Top(stack));
printf("Capacity: %d\n", SeqStack_Capacity(stack));
printf("Length: %d\n", SeqStack_Size(stack));

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

SeqStack_Destroy(stack);
system("pause");
return 0;
}
//创建栈
SeqStack* SeqStack_Create(int capacity)
{
return SeqList_Create(capacity);
}
//销毁
void SeqStack_Destroy(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));
}
//弹栈
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);
}


运行结果：

Top: 9
Capacity: 20
Length: 10
Pop: 9
Pop: 8
Pop: 7
Pop: 6
Pop: 5
Pop: 4
Pop: 3
Pop: 2
Pop: 1
Pop: 0
请按任意键继续. . .

=====================================我是分割线========================================================

栈的链式实现：

     同栈的顺序实现一样，栈的链式实现本质上其实就是单链表的形式，也只是在一头操作罢了，因此我们这里亦采用代码复用的方法，具体代码请参阅：链表的实现与操作(C语言实现) 。



头文件：

#ifndef _LINKSTACK_H_
#define _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


源文件：

#include "stdafx.h"
#include "LinkList.h"
#include "LinkStack.h"
#include <malloc.h>
#include <stdlib.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;

LinkStack_Push(stack, a + i);
}

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

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

LinkStack_Destroy(stack);
system("pause");
return 0;
}

typedef struct _tag_LinkStackNode
{
LinkListNode header;
void* item;
} TLinkStackNode;
//创建
LinkStack* LinkStack_Create()
{
return LinkList_Create();
}

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


运行结果：

Top: 9
Length: 10
Pop: 9
Pop: 8
Pop: 7
Pop: 6
Pop: 5
Pop: 4
Pop: 3
Pop: 2
Pop: 1
Pop: 0
请按任意键继续. . .


如有错误，望不吝指出~
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签：  栈 栈的实现 栈的操作 栈的C语言实现 数据结构
相关文章推荐
新的分享
章节导航