链栈

1. # include <stdio.h>  
2. # include <stdlib.h>  
3. typedef char NodeData;  
4. //链栈  
5. typedef struct Node  
6. {  
7.     NodeData data;  
8.     struct Node *next;  
9. }StackNode;  
10. typedef struct  
11. {  
12.     StackNode *top;  
13. }  
14. LinkStack;  
15. /*置栈空*/  
16. void initStack(LinkStack *ls)  
17. {  
18.     ls->top=NULL;  
19. }  
20. /*判栈空*/  
21. int isStackEmpty(LinkStack *ls)  
22. {  
23.     return ls->top==NULL;  
24. }  
25. /*进栈*/  
26. void pushStack(LinkStack *ls,NodeData nodedata)  
27. {  
28.     StackNode *p;  
29.     p=(StackNode *)malloc(sizeof(StackNode));  
30.     p->data=nodedata;  
31.     p->next=ls->top;  
32.     ls->top=p;  
33. }  
34. /*出栈*/  
35. NodeData popStack(LinkStack *ls)  
36. {  
37.     StackNode *p=ls->top;  
38.     NodeData popNode=ls->top->data;  
39.     ls->top=ls->top->next;  
40.     free(p);  
41.     return popNode;  
42. }  
43. /*打印栈*/  
44. void printStack(LinkStack *ls)  
45. {  
46.     int i=0;  
47.     StackNode *node;  
48.     node=ls->top;  
49.     while(node->next!=NULL)  
50.     {  
51.         node=node->next;  
52.         printf("%d = %c\n",i,node->data);  
53.         i++;  
54.     }  
55. }  
56. /* LinkStack结构类型的定义是为了方便在函数体中修改top指针本身通过修改指向LinkStack的top指针来控制入栈和出栈 */  
57. /* 是通过指针参数修改指针所指内容的典型用法 */  
58. void main()  
59. {  
60.     LinkStack *ls;  
61.     char inData;  
62.     ls=(LinkStack *)malloc(sizeof(LinkStack));  
63.     initStack(ls);  
64.     //入栈  
65.     printf("请输入data\n");  
66.     while(inData != '\n')  
67.     {  
68.         scanf("%c",&inData);  
69.         pushStack(ls,inData);  
70.         printf("%c\n",inData);  
71.     }  
72.     printf("linkStack:\n");  
73.     //打印栈元素  
74.     printStack(ls);  
75.     printf("pop stack\n");  
76.     //出栈  
77.     popStack(ls);  
78.     printStack(ls);  
79. }  

80. # include <stdio.h>
    # include <stdlib.h>
    typedef char NodeData;
    //链栈
    typedef struct Node
    {
        NodeData data;
        struct Node *next;
    }StackNode;
    typedef struct
    {
        StackNode *top;
    }
    LinkStack;
    /*置栈空*/
    void initStack(LinkStack *ls)
    {
    	ls->top=NULL;
    }
    /*判栈空*/
    int isStackEmpty(LinkStack *ls)
    {
        return ls->top==NULL;
    }
    /*进栈*/
    void pushStack(LinkStack *ls,NodeData nodedata)
    {
        StackNode *p;
        p=(StackNode *)malloc(sizeof(StackNode));
        p->data=nodedata;
        p->next=ls->top;
        ls->top=p;
    }
    /*出栈*/
    NodeData popStack(LinkStack *ls)
    {
        StackNode *p=ls->top;
        NodeData popNode=ls->top->data;
        ls->top=ls->top->next;
        free(p);
        return popNode;
    }
    /*打印栈*/
    void printStack(LinkStack *ls)
    {
        int i=0;
        StackNode *node;
        node=ls->top;
        while(node->next!=NULL)
        {
            node=node->next;
            printf("%d = %c\n",i,node->data);
            i++;
        }
    }
    /* LinkStack结构类型的定义是为了方便在函数体中修改top指针本身通过修改指向LinkStack的top指针来控制入栈和出栈 */
    /* 是通过指针参数修改指针所指内容的典型用法 */
    void main()
    {
        LinkStack *ls;
        char inData;
        ls=(LinkStack *)malloc(sizeof(LinkStack));
        initStack(ls);
        //入栈
        printf("请输入data\n");
        while(inData != '\n')
        {
            scanf("%c",&inData);
            pushStack(ls,inData);
            printf("%c\n",inData);
        }
        printf("linkStack:\n");
        //打印栈元素
        printStack(ls);
        printf("pop stack\n");
        //出栈
        popStack(ls);
        printStack(ls);
    }