（C语言版）栈和队列（一）——实现链式栈和链式队列的基本操作以及遇到的问题

http://blog.csdn.net/fisherwan/article/details/20055179

首先要感谢这位大牛的一篇博客，地址如下：http://blog.csdn.net/hguisu/article/details/7674195

当然还有网上一些其他的资料，今天自己写了一下链式栈和链式队列的程序。其中在释放内存的时候遇到了些许问题，通过调，找出了原因，在这里我与大家分享一下。

（1）链式栈的相关代码块

Stack.h 头文件——定义了节点结构和链式栈结构，以及基本操作函数的声明部分

[cpp] view plain copy

1. #ifndef _STACK_H_H  
2. #define _STACK_H_H  
3.   
4. typedef struct Node  
5. {  
6.     int data;  
7.     struct Node *pNext;  
8. }NODE, *pNODE;  
9.   
10. typedef struct Stack  
11. {  
12.     pNODE top;  
13. }STACK, *pSTACK;  
14.   
15. //栈初始化  
16. void InitStack(pSTACK stack);  
17.   
18. //入栈  
19. void PushStack(pSTACK stack, int data);  
20.   
21. //出栈  
22. void PopStack(pSTACK stack, int *data);  
23.   
24. //判断栈是否为空  
25. int IsEmptyStack(pSTACK stack);  
26.   
27. //获得栈顶元素  
28. int GetTopStack(pSTACK stack);  
29.   
30. //释放内存  
31. void FreeMemory(pSTACK stack);  
32.   
33. #endif  

Stack.cpp源文件——定义链式栈的基本操作函数的定义

说明：一开始对栈初始化，但是这个栈是没有头节点的，直接定义了一个指针（top）刚开始指向NULL。

入栈的时候就是让top指针始终指向栈顶元素，入栈的节点的指针指向top指针，这样不断的进行入栈操作，节点不断增加，但是top指针一直是指针最后插入的节点。

出栈的时候就是从top指针指向的节点还是释放，然后让top指针指向被释放节点的下一个节点，这样节点不断释放，top指针不断向下移动。

所以，栈就成了一个“先进后出”的结构。

[cpp] view plain copy

1. #include "Stack.h"  
2. #include <stdlib.h>  
3. #include <stdio.h>  
4.   
5. //栈初始化  
6. void InitStack(pSTACK stack)  
7. {  
8.     stack->top = NULL;  
9. }  
10.   
11. //入栈  
12. void PushStack(pSTACK stack, int data)  
13. {  
14.     pNODE p_new = (pNODE)malloc(sizeof(NODE));  
15.   
16.     if (NULL == p_new)  
17.     {  
18.         printf("内存分配失败！\n");  
19.         exit(EXIT_FAILURE);  
20.     }  
21.       
22.     p_new->data = data;  
23.     p_new->pNext = stack->top; //这里要注意  
24.     stack->top = p_new;  
25. }  
26.   
27. //出栈  
28. void PopStack(pSTACK stack, int *data)  
29. {  
30.     pNODE p_delete = stack->top;  
31.   
32.     if (IsEmptyStack(stack))  
33.         exit(EXIT_FAILURE);  
34.   
35.     *data = p_delete->data;  
36.     stack->top = p_delete->pNext;  
37.     free(p_delete);  
38.     p_delete = NULL;  
39. }  
40.   
41. //判断栈是否为空  
42. int IsEmptyStack(pSTACK stack)  
43. {  
44.     if (stack->top == NULL)  
45.         return 1;  
46.     else  
47.         return 0;  
48. }  
49.   
50. //获得栈顶元素  
51. int GetTopStack(pSTACK stack)  
52. {  
53.     int data;  
54.     if (stack->top == NULL)  
55.         exit(EXIT_FAILURE);  
56.   
57.     data = stack->top->data;  
58.     return data;  
59. }  
60.   
61. //释放内存  
62. void FreeMemory(pSTACK stack)  
63. {  
64.     pNODE p_delete = NULL;  
65.   
66.     while (stack->top != NULL)  
67.     {  
68.         p_delete = stack->top;  
69.         stack->top = p_delete->pNext;  
70.         free(p_delete);  
71.         p_delete = NULL;  
72.     }  
73. }  

main.cpp 测试程序——通过简单的交互界面测试函数的功能

[cpp] view plain copy

1. #include <stdio.h>  
2. #include "Stack.h"  
3.   
4. int main(void)  
5. {  
6.     int number, i, data, flag;  
7.     STACK s;  
8.     InitStack(&s);  
9.       
10.     printf("请输入入栈个数：");  
11.     scanf("%d", &number);  
12.     for (i=1; i<number+1; i++)  
13.     {  
14.         printf("请输入第%d个栈点元素值：", i);  
15.         scanf("%d", &data);  
16.         PushStack(&s, data);  
17.     }  
18.       
19.     PopStack(&s ,&data);  
20.     printf("出栈的元素值为：%d\n", data);  
21.   
22.     data = GetTopStack(&s);  
23.     printf("当前栈顶元素值为：%d\n", data);  
24.   
25.     FreeMemory(&s);  
26.     flag = IsEmptyStack(&s);  
27.     if (flag)  
28.         printf("内存释放成功！\n");  
29.     else  
30.         printf("内存释放失败！\n");  
31.   
32.     return 0;  
33. }  

（2）链式队列的相关代码

Queue.h 头文件——定义了节点结构和队列结构，以及链式队列的基本操作函数的声明

[cpp] view plain copy

1. #ifndef _QUEUE_H_H  
2. #define _QUEUE_H_H  
3.   
4. typedef struct Node  
5. {  
6.     int data;  
7.     struct Node *pNext;  
8. }NODE, *pNODE;  
9.   
10. typedef struct Queue  
11. {  
12.     pNODE front;      
13.     pNODE rear;  
14. }QUEUE, *pQUEUE;  
15.   
16. //初始化队列  
17. void InitQueue(pQUEUE queue);  
18.   
19. //入队列  
20. void EnQueue(pQUEUE queue, int data);  
21.   
22. //出队列  
23. void DeQueue(pQUEUE queue, int *data);  
24.   
25. //判断队列是否为空  
26. int IsEmptyQueue(pQUEUE queue);  
27.   
28. //获得队头元素值  
29. int GetFrontQueue(pQUEUE queue);  
30.   
31. //释放内存  
32. void FreeMemory(pQUEUE queue);  
33.   
34. #endif  

Queue.cpp源文件——定义了基本操作函数的定义

说明：一开始对链式队列进行初始化，这里就创建了一个节点（但是记得后面释放内存的时候这里也要释放），创建了这个节点是为了方便后面的操作，这样一开始队列的头指针和尾指针都指向了这个节点，但是此时的队列是空的，就像循环链表里头节点不参与运行是一样的道理。

入队列的时候就是进入的节点排在初始化时创建的节点后面，然后尾指针指针指着新进入的节点，但是头指针不动，节点不断进入队列，尾指针不断向后移动，保持尾指针一直指着刚进入的节点。

出队列的时候就是让头指针指向的节点的指针指向要释放节点的下一个节点，节点不断出队列，这里头指针实质上并没有移动，但是它指向的节点的指针一直在变化，一直保持者指向要释放节点的下一个节点，但是这里要注意，就是当队列中只剩下一个节点的时候（这里不包含初始化创建的那个节点），释放了这个节点以后尾指针成了野指针，那么这个时候就要让尾指针和头指针指向同一位置，那么这样判断队列是否为空的时候就是空了。

[cpp] view plain copy

1. //链式队列代码  
2. #include <stdlib.h>  
3. #include <stdio.h>  
4. #include "Queue.h"  
5.   
6. //初始化队列  
7. void InitQueue(pQUEUE queue)  
8. {  
9.     queue->front = (pNODE)malloc(sizeof(NODE));  
10.     queue->front->data = 0;  
11.     queue->front->pNext = NULL;  
12.   
13.     if (NULL == queue->front)  
14.     {  
15.         printf("内存分配失败！\n");  
16.         exit(EXIT_FAILURE);  
17.     }  
18.   
19.     queue->rear = queue->front;  
20. }  
21.   
22. //入队列  
23. void EnQueue(pQUEUE queue, int data)  
24. {  
25.     pNODE p_new = (pNODE)malloc(sizeof(QUEUE));  
26.   
27.     if (NULL == p_new)  
28.     {  
29.         printf("内存分配失败！\n");  
30.         exit(EXIT_FAILURE);  
31.     }  
32.   
33.     p_new->data = data;  
34.     p_new->pNext = NULL;  
35.     queue->rear->pNext = p_new;  
36.     queue->rear = p_new;  
37. }  
38.   
39. //出队列  
40. void DeQueue(pQUEUE queue, int *data)  
41. {  
42.     if (IsEmptyQueue(queue))  
43.         exit(EXIT_FAILURE);  
44.     pNODE p_delete = queue->front->pNext;  
45.     *data = p_delete->data;  
46.     queue->front->pNext = p_delete->pNext;  
47.     if (p_delete->pNext == NULL)  
48.         queue->rear = queue->front;  
49.     free(p_delete);  
50.     p_delete = NULL;  
51. }  
52.   
53. //判断队列是否为空  
54. int IsEmptyQueue(pQUEUE queue)  
55. {  
56.     if (queue->front == queue->rear)  
57.         return 1;  
58.     else  
59.         return 0;  
60. }  
61.   
62. //获得队头元素值  
63. int GetFrontQueue(pQUEUE queue)  
64. {  
65.     int data;  
66.     if (IsEmptyQueue(queue))  
67.         exit(EXIT_FAILURE);  
68.     data = queue->front->data;  
69.     return data;  
70. }  
71.   
72. //释放内存  
73. void FreeMemory(pQUEUE queue)  
74. {  
75.     pNODE p_delete = NULL;  
76.     while (queue->front != NULL)  
77.     {  
78.         p_delete = queue->front;  
79.         queue->front = p_delete->pNext;  
80.         if (p_delete->pNext == NULL) //如果到达最后一个节点时，队尾指针为NULL  
81.             queue->rear = NULL;  
82.         free(p_delete);  
83.         p_delete = NULL;  
84.     }  
85. }  

main.cpp 测试程序——简单的交互界面测试函数功能

[cpp] view plain copy

1. #include <stdio.h>  
2. #include "Queue.h"  
3.   
4. int main(void)  
5. {  
6.     int number, i, data, flag;  
7.     QUEUE q;  
8.     InitQueue(&q);  
9.       
10.     flag = IsEmptyQueue(&q);  
11.     if (flag)  
12.         printf("初始化成功！\n");  
13.   
14.     printf("请输入入队列个数：");  
15.     scanf("%d", &number);  
16.     for (i=1; i<number+1; i++)  
17.     {  
18.         printf("请输入第%d个队点元素值：", i);  
19.         scanf("%d", &data);  
20.         EnQueue(&q, data);  
21.     }  
22.   
23.     DeQueue(&q ,&data);  
24.     printf("出队列的元素值为：%d\n", data);  
25.   
26.     data = GetFrontQueue(&q);  
27.     printf("当前栈顶元素值为：%d\n", data);  
28.   
29.     FreeMemory(&q);  
30.     if (q.front == NULL && q.rear == NULL)  
31.         printf("内存释放成功！\n");  
32.     else  
33.         printf("内存释放失败！\n");  
34.   
35.     return 0;  
36. }