链式存储

链表存储结构的内存地址不一定是连续的，但顺序存储结构的内存地址一定是连续的；链式存储适用于在较频繁地插入、删除、更新元素时，而顺序存储结构适用于频繁查询时使用。所以本文主要基于前文的基础，讨论链式存储结构的堆栈。

1、链式存储（不连续内存）

/*链式结构*/
typedef struct _STACK_NODE
{
    int pData;
    struct _STACK_NODE *next;
}STACK_NODE,*LinkStackPtr;

typedef struct LinkStack
{
    LinkStackPtr top;//栈顶指针的位置
    int count;      //统计当前堆栈中包含多少数据
}LinkStack;
   
   
1
2
3
4
5
6
7
8
9
10
11
12
   
   
1
2
3
4
5
6
7
8
9
10
11
12

（2）初始化堆栈

STATUS  init_stack(LinkStack pStackNode)
{
    pStackNode->top= NULL;//空栈，头指针指向空
    pStackNode->count = 0;

    return OK;
}

   
   
1
2
3
4
5
6
7
8
   
   
1
2
3
4
5
6
7
8

（3）释放堆栈

STATUS free_stack(LinkStack* pStackNode)
{
    LinkStackPtr *p = NULL;
    if(NULL == pStackNode)
        return FALSE;

    assert(NULL != pStackNode->top);
    p = pStackNode->top->next; //保存下一个结点

    while(pStackNode->count && p){ 
        p = pStackNode->top->next;//保存
        free(pStackNode->top);
        pStackNode->top = p;//重新赋值栈顶指针
        pStackNode->count--;
    }
    return TRUE;
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（4）堆栈压入数据 

STATUS stack_push(LinkStack* pStackNode, int value)
{
    LinkStackPtr *p;
    p = (LinkStackPtr*)malloc(sizeof(LinkStackPtr));
    if(NULL == p)
        return FALSE;

    p->pData = value;//赋值
    p->next = pStackNode->top;//当前的栈顶元素赋值给新结点如图①
    pStackNode->top = p;//新结点赋值给栈顶元素，如图②
    pStackNode->count++;

    return TRUE;
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（5）堆栈弹出数据

STATUS stack_pop(LinkStack* pStackNode, int* value)
{
    LinkStackPtr *p;
    if(NULL == pStackNode || NULL == value)
        return FALSE;
    *value   = pStackNode->top->data;//返回值
    p = pStackNode->top;
    pStackNode->top = pStackNode->top->next;
    free(p);
    p = NULL;

    pStackNode->count--;

    return TRUE;
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（6）统计当前堆栈中包含多少数据

int count_stack_number(const LinkStack* pStackNode)
{
    return pStackNode->count;
}

   
   
1
2
3
4
5
   
   
1
2
3
4
5

全部代码如下：

//链式存储
//Written by ZP1015
//2015.10.18

#include "stdafx.h"

#include <stdio.h>
#include <stdlib.h>


#define OK 0
#define ERROR -1

/*链式结构*/
struct STACK_NODE
{
    int pData;
    struct STACK_NODE *next;
};


struct LinkStack
{
    struct STACK_NODE *top;//栈顶指针的位置
    int StackLen;      //统计当前堆栈中包含多少数据
};

int init_stack(struct LinkStack *pStackNode)
{
    pStackNode->top= NULL;//空栈，头指针指向空
    pStackNode->StackLen = 0;

    return OK;
}

int empty_stack(struct LinkStack *pStackNode)
{
    /*1.输入的参数有误*/
    if(NULL == pStackNode) {
        printf("[%d] pStackNode is illegal! \n",__LINE__);
        return ERROR;
    }
    /*2.输入的链式堆栈为空*/
    if(NULL == pStackNode->top) {
        printf("[%d] pStackNode is empty!\n",__LINE__);
        return ERROR;
    }

    struct STACK_NODE *pStackNodeTopNext = NULL;

   /*3.清空链表*/
    while(pStackNode->StackLen){ 
        pStackNodeTopNext = pStackNode->top->next;//保存
        free(pStackNode->top);
        pStackNode->top = NULL;/*set to NULL*/
        pStackNode->top = pStackNodeTopNext;//重新赋值栈顶指针
        pStackNode->StackLen--;/*Stack len */
    }
    return OK;
}


int  push_stack(struct LinkStack *pStackNode, int value)
{
    /*1.输入的参数有误*/
    if(NULL == pStackNode) {
        printf("[%d] pStackNode is illegal! \n",__LINE__);
        return ERROR;
    }

    struct STACK_NODE *pStackNodeTemp = NULL;

    pStackNodeTemp = (struct STACK_NODE*)malloc(sizeof(struct STACK_NODE));
    if(NULL == pStackNodeTemp) {
        printf("[%d] malloc failed!\n",__LINE__);
        return ERROR;
    }

    pStackNodeTemp->pData = value;//赋值
    pStackNodeTemp->next = pStackNode->top;//当前的栈顶元素赋值给新结点如图①
    pStackNode->top = pStackNodeTemp;//新结点赋值给栈顶元素，如图②
    pStackNode->StackLen ++;

    return OK;
}

int  pop_stack(struct LinkStack *pStackNode, int* value)
{

    /*1.输入的参数有误*/
    if(NULL == pStackNode || NULL == value) {
        printf("[%d] pStackNode is illegal! \n",__LINE__);
        return ERROR;
    }
    /*2.输入的链式堆栈为空*/
    if(NULL == pStackNode->top) {
        printf("[%d] pStackNode is empty!\n",__LINE__);
        return ERROR;
    }

    struct STACK_NODE *pStackNodeTemp = NULL;

    *value   = pStackNode->top->pData;
    pStackNodeTemp = pStackNode->top;
    pStackNode->top = pStackNode->top->next;
    free(pStackNodeTemp);
    pStackNodeTemp = NULL;

    pStackNode->StackLen--;

    return OK;
}

int count_stack_length(struct LinkStack pStackNode)
{
    return pStackNode.StackLen;
}

void print_stack_node(struct LinkStack *pStackNode) 
{
    /*1.输入的参数有误*/
    if(NULL == pStackNode) {
        printf("[%d] pStackNode is illegal! \n",__LINE__);
        return;
    }
    /*2.输入的链式堆栈为空*/
    if(NULL == pStackNode->top) {
        printf("[%d] pStackNode is empty!\n",__LINE__);
        return ;
    }
    struct STACK_NODE *pStackNodeTemp = pStackNode->top;

    while(pStackNodeTemp!= NULL) {
        printf("%d ",pStackNodeTemp->pData);
        pStackNodeTemp = pStackNodeTemp->next;
    }
    printf("\n");
}

int main()
{
    struct LinkStack pStackNode;
    init_stack(&pStackNode);
    for (int i = 0;i<10;i++) {
        push_stack(&pStackNode,i);
    }
    print_stack_node(&pStackNode);
    /*test pop*/
#if 0
    int a = 0;
    pop_stack(pStackNode,&a);
    print_stack_node(pStackNode);
#endif  

#if 0
    printf("%d\n",count_stack_length(pStackNode));
#endif

    empty_stack(&pStackNode);
    print_stack_node(&pStackNode);
    getchar();
    getchar();

    return 0;
}


   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
   
   


   
   
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167