Linux　c　算法与数据结构－－栈

前段时间写了双向链表，现在写个栈，写之前，先简单介绍链表　队列　　栈的区别：

链表，队列，堆栈的区别

1、栈是个有底的口袋，像袜子。

队列是没底的口袋，像通心粉。

所以：栈的特点是先进后出，队列的特点是先进先出。

2、主要区别是适用的地方不一样,

链表实际上可以认为是一种数据的物理组织形式,是用指针或对象的引用组织起的一种数据的存储方式.

队列和堆栈是一个更高层次的概念,其底层可以是用链表也可以是用数组来实现.

队列和堆栈的主要区别是进出的顺序不一样,

队列是先进先出,堆栈是后进先出.

3、cooled(经典中--经过非典中) 说的很详细了，我补充一下

队列和堆栈是一种特殊的数据组织形式。

可以把他们看成是一系列的集合。

队列可以看成是有2个口的集合一个口叫队头一个叫队尾，只能在对头进行删除操作，在队尾做插入。根据这样的操作。队列特点是先进先出

堆栈可以看成是有1个口的集合，这个口叫栈顶。插入和删除操作只能在栈顶操作。根据这样的操作。堆栈的特点是是后进先出.

链表是一种存储方式，它可以在非连续的内存空间里面存储一个集合的元素。和它对应的是数组，数组要在连续的空间里存储集合的元素

下面是栈的实验代码：

Stack.h

#ifndef _Stack_H
#define _Stack_H

typedef struct node
{
int data;
struct node *down;
}PNode;

typedef struct stack
{
PNode *top;
int size;
}Stack;

Stack *InitStack();

void DestroyStack(Stack *ps);

void ClearStack(Stack *ps);

int IsEmpty(Stack *ps);

int GetSize(Stack *ps);

PNode *GetTop(Stack *ps,int *pitem);

PNode *Push(Stack *ps,int item);

PNode *Pop(Stack *ps,int *pitem);

void StackTraverse(Stack *ps,void (*visit)());

#endif

Stack.c

#include <stdio.h>
#include "Stack.h"
#include <malloc.h>
#include <stdlib.h>

Stack *InitStack()
{
Stack *ps;
ps=(Stack *)malloc(sizeof(Stack));
if(ps!=NULL)
{
ps->top = NULL;
ps->size = 0;
}
return ps;
}

void DestroyStack(Stack *ps)
{
if(IsEmpty(ps)!=1)
ClearStack(ps);
free(ps);
}

void ClearStack(Stack *ps)
{
while(IsEmpty(ps)!=1)
{
Pop(ps,NULL);
}
}

int IsEmpty(Stack *ps)
{
if(ps->top == NULL&&ps->size == 0)
return 1;
}

int GetSize(Stack *ps)
{
return ps->size;
}

PNode *GetTop(Stack *ps,int *pitem)
{
if(IsEmpty(ps)!=1&&pitem!=NULL)
{
*pitem = ps->top->data;
}
return ps->top;
}

PNode *Push(Stack *ps,int item)
{
PNode *pnode = (PNode *)malloc(sizeof(PNode));
if(pnode!=NULL)
{
pnode->data = item;
pnode->down = GetTop(ps,NULL);
ps->size++;
ps->top = pnode;
}
return pnode;
}

PNode *Pop(Stack *ps,int *pitem)
{
PNode *pnode = ps->top;
if(IsEmpty(ps)!=1&&pnode!=NULL)
{
if(pitem!=NULL)
*pitem = pnode->data;
ps->size--;
ps->top = ps->top->down;
free(pnode);
}
return ps->top;
}

void StackTraverse(Stack *ps,void(*visit)())
{
PNode *p = ps->top;
int i = ps->size;
while(i--)
{
visit(p->data);
p = p->down;
}
}

Test.c

#include "Stack.h"
#include <stdio.h>

void print(int i)
{
printf("The data of this node is:%d\n",i);
}

int main()
{
Stack *ps = InitStack();
int i,item;

printf("0-9 push in stack,and print:\n");
for(i=0;i<10;i++)
{
Push(ps,i);
GetTop(ps,&item);
printf("%d",item);
}

printf("\nTraverse from stacktop to stack down and print\n");
StackTraverse(ps,print);

printf("The data of stack pop as it's turn and print:\n");
for(i=0;i<10;i++)
{
Pop(ps,&item);
printf("%d",item);
}

ClearStack(ps);
if(IsEmpty(ps))
printf("\nIt is a success to clear the stack\n");
DestroyStack(ps);
printf("The stack is destroyed!\n");
}

执行结果如下：



makefile: