Linux　c　算法与数据结构－

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

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

链表，队列，堆栈的区别
1、栈是个有底的口袋，像袜子。
队列是没底的口袋，像通心粉。
所以：栈的特点是先进后出，队列的特点是先进先出。
2、主要区别是适用的地方不一样,
链表实际上可以认为是一种数据的物理组织形式,是用指针或对象的引用组织起的一种数据的存储方式.
队列和堆栈是一个更高层次的概念,其底层可以是用链表也可以是用数组来实现.
队列和堆栈的主要区别是进出的顺序不一样,
队列是先进先出,堆栈是后进先出.
3、cooled(经典中--经过非典中) 说的很详细了，我补充一下
队列和堆栈是一种特殊的数据组织形式。
可以把他们看成是一系列的集合。
队列可以看成是有2个口的集合一个口叫队头一个叫队尾，只能在对头进行删除操作，在队尾做插入。根据这样的操作。队列特点是先进先出
堆栈可以看成是有1个口的集合，这个口叫栈顶。插入和删除操作只能在栈顶操作。根据这样的操作。堆栈的特点是是后进先出.
链表是一种存储方式，它可以在非连续的内存空间里面存储一个集合的元素。和它对应的是数组，数组要在连续的空间里存储集合的元素

下面是栈的实验代码：

Stack.h

[cpp] view plaincopy  
 #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

[cpp] view plaincopy  
 #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

[cpp] view plaincopy  
 #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");  
 }  