（4）数据结构——栈（链表）实现

LinkList.h

  1 /*********************************************************************
  2 *:
  3 *:
  4 *:          Author: dspeeding
  5 *:          Copyright (c) 2012, dspeeding
  6 *:
  7 *:        Created at: 2012.06.15
  8 *:     Last modified: 2012.06.15  
  9 *:             
 10 *:      Introduction: 链表栈（数据结构）的c实现
 11 *:                    
 12 *:
 13 *:*********************************************************************/
 14 #ifndef _LINKLISTSTACK_H_
 15 #define _LINKLISTSTACK_H_
 16 
 17 #include "ElemType.h"
 18 
 19 /*定义结点结构体*/
 20 typedef struct TDefLinkListStackNode
 21 {
 22     ElemType                            data;        /*数据域*/
 23     struct TDefLinkListStackNode        *next;        /*链表指针*/
 24 }LinkListStackNode;
 25 
 26 typedef LinkListStackNode* PLinkListStackNode;
 27 typedef const LinkListStackNode CLinkListStackNode;
 28 typedef const LinkListStackNode* PCLinkListStackNode;
 29 
 30 
 31 /*定义栈结构体*/
 32 typedef struct TDefLinkListStack
 33 {
 34     PLinkListStackNode pTop;                        /*栈顶指针*/
 35 }LinkListStack;
 36 
 37 typedef LinkListStack* PLinkListStack;
 38 typedef const LinkListStack CLinkListStack;
 39 typedef const LinkListStack* PCLinkListStack;
 40 
 41 
 42 typedef void (*Visit)(ElemType*);
 43 
 44 /****************************************
 45  Purpose :     初始化一个栈
 46  Input   :     pStack        -- 栈指针
 47  Return  :     0        --OK
 48             -1        --FAIL
 49 *****************************************/
 50 int InitLinkListStack(PLinkListStack pStack);
 51 
 52 
 53 /****************************************
 54  Purpose :     判断栈是否为空
 55  Input   :     
 56  Return  :     None
 57 *****************************************/
 58 int IsEmptyLinkListStack(PLinkListStack pStack);
 59 
 60 
 61 /****************************************
 62  Purpose :     进栈
 63  Input   :     pStack        -- 栈指针
 64             pVal        --数据指针
 65  Return  :     0            --OK
 66             -1            --FAIL
 67 *****************************************/
 68 int PushLinkListStack(PLinkListStack pStack, PCElemType pVal);
 69 
 70 
 71 
 72 /****************************************
 73  Purpose :     出栈
 74  Input   :     pStack        -- 栈指针
 75             pVal        --数据指针
 76  Return  :     0            --OK
 77             -1            --FAIL
 78  ******************************************/
 79 int PopLinkListStack(PLinkListStack pStack, PElemType pVal);
 80 
 81 
 82 
 83 /****************************************
 84  Purpose :     取栈顶元素
 85  Input   :     pStack        -- 栈指针
 86             pVal        --数据指针
 87  Return  :     0            --OK
 88             -1            --FAIL
 89 *****************************************/
 90 int GetTopLinkListStack(PLinkListStack pStack, PElemType pVal);
 91 
 92 
 93 /*************************************************************************
 94  Function:     TraverseLinkListStack()
 95  Purpose :     从栈顶开始遍历整个栈
 96  Input   :     pStack        -- 栈指针
 97             visit        -- 遍历函数
 98  Return  :     None
 99  Modify  :
100  Remark  :
101  *************************************************************************/
102 void TraverseLinkListStack(PLinkListStack pStack, Visit visit);
103 
104 
105 
106 /****************************************
107  Purpose :     销毁栈
108  Input   :     pStack        -- 栈指针
109  Return  :     0            --OK
110             -1            --FAIL
111 *****************************************/
112 int DestroyLinkListStack(PLinkListStack pStack);
113 
114 
115 #endif

LinkList.c

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #include "LinkListStack.h"
  5 
  6 /*************************************************************************
  7  Function:     InitLinkListStack()
  8  Purpose :     初始化链表栈
  9  Input   :     pStack        -- 栈指针
 10  Return  :     0            --OK
 11             -1            --FAIL
 12  Modify  :
 13  Remark  :
 14  *************************************************************************/
 15 int InitLinkListStack(PLinkListStack pStack)
 16 {
 17     int nRet;
 18     pStack->pTop = NULL;
 19 }
 20 
 21 /*************************************************************************
 22  Function:     IsEmptyLinkListStack()
 23  Purpose :     判断栈是否为空
 24  Input   :     pStack        -- 栈指针
 25  Return  :     0            --空
 26             其他        --非空
 27  Modify  :
 28  Remark  :
 29  *************************************************************************/
 30 int IsEmptyLinkListStack(PLinkListStack pStack)
 31 {
 32     if(pStack->pTop == NULL)
 33     {
 34         return 0;
 35     }
 36     return -1;
 37 }
 38 
 39 /*************************************************************************
 40  Function:     PushLinkListStack()
 41  Purpose :     进栈
 42  Input   :     pStack        -- 栈指针
 43             pVal        --数据指针
 44  Return  :     0            --OK
 45             -1            --FAIL
 46  Modify  :
 47  Remark  :
 48  *************************************************************************/
 49 int PushLinkListStack(PLinkListStack pStack, PCElemType pVal)
 50 {
 51     PLinkListStackNode pNode = (PLinkListStackNode)malloc(sizeof(LinkListStackNode));
 52     if(pNode == NULL)
 53     {
 54         /*分配内存失败*/
 55         return -1;
 56     }
 57     else
 58     {
 59         memcpy(&pNode->data, pVal, sizeof(ElemType));
 60         pNode->next = pStack->pTop;
 61         pStack->pTop = pNode;
 62         
 63         return 0;
 64     }
 65 }
 66 
 67 /*************************************************************************
 68  Function:     PopLinkListStack()
 69  Purpose :     出栈
 70  Input   :     pStack        -- 栈指针
 71             pVal        --数据指针
 72  Return  :     0            --OK
 73             -1            --FAIL
 74  Modify  :
 75  Remark  :
 76  *************************************************************************/
 77 int PopLinkListStack(PLinkListStack pStack, PElemType pVal)
 78 {
 79     PLinkListStackNode pNode;
 80     if(IsEmptyLinkListStack(pStack) == 0)
 81     {
 82         /*栈已空*/
 83         return -1;
 84     }
 85     
 86     pNode = pStack->pTop;
 87     pStack->pTop = pStack->pTop->next;
 88     memcpy(pVal, &pNode->data, sizeof(ElemType));
 89     free(pNode);
 90     pNode = NULL;
 91     return 0;
 92 }
 93 
 94 /*************************************************************************
 95  Function:     GetTopLinkListStack()
 96  Purpose :     取栈顶元素
 97  Input   :     pStack        -- 栈指针
 98             pVal        --数据指针
 99  Return  :     0            --OK
100             -1            --FAIL
101  Modify  :
102  Remark  :
103  *************************************************************************/
104 int GetTopLinkListStack(PLinkListStack pStack, PElemType pVal)
105 {
106     if(IsEmptyLinkListStack(pStack) == 0)
107     {
108         /*栈以空*/
109         return -1;
110     }
111     memcpy(pVal, &pStack->pTop->data, sizeof(ElemType));
112     return 0;
113 }
114 
115 /*************************************************************************
116  Function:     TraverseLinkListStack()
117  Purpose :     从栈顶开始遍历整个栈
118  Input   :     pStack        -- 栈指针
119             visit        -- 遍历函数
120  Return  :     None
121  Modify  :
122  Remark  :
123  *************************************************************************/
124 void TraverseLinkListStack(PLinkListStack pStack, Visit visit)
125 {
126     PLinkListStackNode p = NULL;
127     p = pStack->pTop;
128     while(p)
129     {
130         visit(&(p->data));
131         p = p->next;
132     }
133 }
134 
135 /*************************************************************************
136  Function:     DestroyLinkListStack()
137  Purpose :     销毁栈
138  Input   :     pStack        -- 栈指针
139  Return  :     0            --OK
140             -1            --FAIL
141  Modify  :
142  Remark  :
143  *************************************************************************/
144 int DestroyLinkListStack(PLinkListStack pStack)
145 {
146     ElemType mVal;
147     while(IsEmptyLinkListStack(pStack))
148     {
149         PopLinkListStack(pStack, &mVal);
150     }
151 }

ElemType.h

 1 #ifndef _ELEMTYPE_H_
 2 #define _ELEMTYPE_H_
 3 
 4 /*定义需要的数据类型，这里可以是基本数据类型，也可以是结构体数据类型，
 5   结构体中最好不要使用指针，使用结构体时请包含相关头文件*/
 6 typedef int ElemType;
 7 typedef ElemType* PElemType;
 8 typedef const ElemType* PCElemType;
 9 
10 
11 /****************************************
12  Purpose :     打印数据
13  Input   :     pVal --要被打印的数据
14  Return  :     None
15 *****************************************/
16  void visit(PCElemType pVal);
17 
18 #endif

ElemType.c

 1 #include <stdio.h>
 2 #include "ElemType.h"
 3 /*************************************************************************
 4  Function:     VisitElemTypeData()
 5  Purpose :     打印输出数据
 6  Input   :     pVal --要被打印的数据
 7  Return  :     None
 8  Modify  :
 9  Remark  :
10  *************************************************************************/
11  void visit(PCElemType pVal)
12  {
13     printf("%d\n",*pVal);
14  }

testmain.c

 1 #include <stdio.h>
 2 #include "LinkListStack.h"
 3 
 4 
 5 void test_normal()
 6 {
 7     ElemType arr[7]={2,5,3,1,4,8,10};
 8     LinkListStack mStack;
 9     int i;
10     ElemType outData;
11     
12     InitLinkListStack(&mStack);
13     for(i=0;i<7;i++)
14     {
15         if(PushLinkListStack(&mStack, &arr[i]))
16         {
17             printf("push stack fail\n");
18         }
19     }
20     
21     if(PopLinkListStack(&mStack, &outData))
22     {
23         printf("pop stack fail\n");
24     }
25     visit(&outData);
26     
27     
28     int a1 = 80;
29     if(PushLinkListStack(&mStack, &a1))
30     {
31         printf("push stack fail\n");
32     }
33     
34     
35     if(GetTopLinkListStack(&mStack, &outData))
36     {
37         printf("getTop stack fail\n");
38     }
39     visit(&outData);
40     
41     
42     while(IsEmptyLinkListStack(&mStack))
43     {
44         if(PopLinkListStack(&mStack, &outData))
45         {
46             printf("pop stack fail\n");
47         }
48         visit(&outData);
49     }
50     
51     
52     DestroyLinkListStack(&mStack);
53 }
54 
55 
56 int main()
57 {
58     test_normal();
59     return 0;
60 }

posted on 2013-08-07 12:33 dspeeding 阅读(365) 评论(0) 编辑收藏举报