数据结构——链栈

（一）头文件

  1 #ifndef _LINKSTACK_H_
  2 #define _LINKSTACK_H_
  3 
  4 #define SUCCESS      1000
  5 #define FAILURE      1001
  6 
  7 typedef int DataType;
  8 
  9 struct node                 //表示结点的信息
 10 {
 11     DataType data;
 12     struct node *next;
 13 };
 14 typedef struct node Node;
 15 
 16 struct stack                //表示栈的信息
 17 {
 18     Node *top;
 19     int length;
 20 };
 21 typedef struct stack LinkStack;
 22 
 23 int InitStack(LinkStack **s);
 24 int EmptyStack(LinkStack *s);
 25 int Push(LinkStack *s, DataType e);
 26 int StackLength(LinkStack *s);
 27 int TraverseStack(LinkStack *s);
 28 int GetTop(LinkStack *s, DataType *e);
 29 int Pop(LinkStack *s, DataType *e);
 30 int ClearStack(LinkStack *s);
 31 int DestroyStack(LinkStack **s);
 32 #endif

（二）调用函数

#include <stdio.h>
  2 #include "LinkStack.h"
  3 #include <stdlib.h>
  4 
  5 int InitStack(LinkStack **s)
  6 {
  7     (*s) = (LinkStack *)malloc(sizeof(LinkStack));
  8     if (NULL == (*s))
  9     {
 10         return FAILURE;
 11     }
 12 
 13     (*s)->top = NULL;
 14     (*s)->length = 0;
 15 
 16     return SUCCESS;
 17 }
 18 
 19 int EmptyStack(LinkStack *s)
 20 {
 21     return (NULL == s->top) ? SUCCESS : FAILURE;
 22 }
 23 
 24 int Push(LinkStack *s, DataType e)
 25 {
 26     if (s == NULL)
 27     {
 28         return FAILURE;
 29     }
 30 
 31     Node *p = (Node *)malloc(sizeof(Node));
 32     if (NULL == p)
 33     {
 34         return FAILURE;
 35     }
 36 
 37     p->data = e;
 38     p->next = s->top;
 39     s->top = p;
 40     s->length++;
 41 
 42     return SUCCESS;
 43 }
 44 
 45 int StackLength(LinkStack *s)
 46 {
 47     return (s->length);
 48 }
 49 
 50 int TraverseStack(LinkStack *s)
 51 {
 52     Node *p = s->top;
 53 
 54     while (p)
 55     {
 56         printf("%d ", p->data);
 57         p = p->next;
 58     }
 59 
 60     return SUCCESS;
 61 }
 62 
 63 int GetTop(LinkStack *s, DataType *e)
 64 {
 65     if (NULL == s->top)
 66     {
 67         return FAILURE;
 68     }
 69 
 70     *e = s->top->data;
 71 
 72     return SUCCESS;
 73 }
 74 
 75 int Pop(LinkStack *s, DataType *e)
 76 {
 77     Node *p;
 78 
 79     if (NULL == s->top)
 80     {
 81         return FAILURE;
 82     }
 83 
 84     *e = s->top->data;
 85 
 86     p = s->top;
 87     s->top = s->top->next;
 88     free(p);
 89     s->length--;
 90 
 91     return SUCCESS;
 92 
 93 }
 94 
 95 int ClearStack(LinkStack *s)
 96 {
 97     Node *p = s->top;
 98 
 99     while (p)
100     {
101         s->top = s->top->next;
102         free(p);
103         s->length--;
104         p = s->top;
105     }
106 
107     return SUCCESS;
108 }
109 
110 int DestroyStack(LinkStack **s)
111 {
112     if (NULL == *s)
113     {
114         return FAILURE;
115     }
116     free(*s);
117     *s = NULL;
118 
119     return SUCCESS;

（三）主函数

  1#include <stdio.h>
  2 #include "LinkStack.h"
  3
  4 int main()
  5 {
  6     int ret, i;
  7     LinkStack *stack;
  8     DataType e;
  9
 10     ret = InitStack(&stack);
 11     if (SUCCESS == ret)
 12     {
 13         printf("Init Success!\n");
 14     }
 15     else
 16     {
 17         printf("Init Failure!\n");
 18     }
 19
 20     ret = EmptyStack(stack);
 21     if (SUCCESS == ret)
 22     {
 23         printf("Stack is Empty!\n");
 24     }
 25     else
 26     {
 27         printf("Stack isn't Empty!\n");
 28     }
 29
 30     for (i = 0; i < 5; i++)
 31     {
 32         ret = Push(stack, i + 1);
 33         if (SUCCESS == ret)
 34         {
 35             printf("Push %d Success!\n", i +1);
 36         }
 37         else
 38         {
 39             printf("Push %d Failure!\n");
 40         }
 41     }
 42     printf("%d\n", stack->length);
 43
 44     ret = EmptyStack(stack);
 45     if (SUCCESS == ret)
 46     {
 47         printf("Stack is Empty!\n");
 48     }
 49     else
 50     {
 51         printf("Stack isn't Empty!\n");
 52     }
 53
 54     printf("Stack Length is %d\n", StackLength(stack));
 55
 56     ret = TraverseStack(stack);
 57     if (SUCCESS == ret)
 58     {
 59         printf("Traverse Success!\n");
 60     }
 61
 62     ret = GetTop(stack, &e);
 63     if (SUCCESS == ret)
 64     {
 65         printf("Top is %d\n", e);
 66     }
 67     else
 68     {
 69         printf("Get Top Failure!\n");
 70     }
 71
 72     for (i = 0; i < 3; i++)
 73     {
 74         ret = Pop(stack, &e);
 75         if (SUCCESS == ret)
 76         {
 77             printf("Pop %d Success!\n", e);
 78         }
 79         else
 80         {
 81             printf("Pop Failure!\n");
 82         }
 83     }
 84
 85     ret = ClearStack(stack);
 86     if (SUCCESS == ret)
 87     {
 88         printf("Clear Success!\n");
 89     }
 90
 91     ret = TraverseStack(stack);
 92     if (SUCCESS == ret)
 93     {
 94         printf("Traverse Success!\n");
 95     }
 96
 97     ret = DestroyStack(&stack);
 98     if (SUCCESS == ret)
 99     {
100         printf("Destroy Success!\n");
101     }
102
103
104     for (i = 0; i < 5; i++)
105     {
106         ret = Push(stack, i + 1);
107         if (SUCCESS == ret)
108         {
109             printf("Push %d Success!\n", i +1);
110         }
111         else
112         {
113             printf("Push %d Failure!\n");
114         }
115     }
116
117     return 0;

118    }