谁来答我心中的疑惑

chao_prince

首先，楼主的代码似乎有很多手误的敲错的地方。。其次，这种方法是定义了一个头结点和尾结点，各种方法都有好有坏，根据各人喜好，或者需求来选择，定义头结点的好处在于，对于插入和删除编码比较方便，不用考虑空表的特殊情况，至于尾结点，可以让在尾部插入比较方便。。
、

故乡的风

首先，这对两个结构体，我觉得写的很好。可读性也很强，第一个结构体写的是节点，第二个结构体是整个链栈，很清晰。其次，我并没有觉得它有哪个地方占用了很大的内存空间，除了节点处，基本没有其他内存占用。把节点独立出来，使得操作更方便，写节点的时候不用考虑其他的，写链栈的时候也不需要管链表，只要知道链表首地址和节点数就行了。两者之间联系越小，考虑就越简单，操作越简单，可读性越好。

故乡的风

其实，lz可以学习下这种处理方式。把数据和结构独立出来，把结构和操作联系起来，这样写出来的代码会更好，层次性也会更强。

故乡的风

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElemType;
   
5. 
   
6. typedef int BOOL;
   
7. #define TRUE  1
   
8. #define FALSE 0
   
9. 
   
10. //链栈节点
    
11. typedef struct StackNode {
    
12.         ElemType data;
    
13.         struct StackNode *next;
    
14. } StackNode, *LinkStackPtr;
    
15. 
    
16. //链栈
    
17. typedef struct LinkStack {
    
18.         LinkStackPtr top;        //栈顶
    
19.         int count;                        //节点数
    
20. } LinkStack;
    
21. 
    
22. //初始化链栈
    
23. BOOL InitStack(LinkStack &stack) {
    
24.         stack.top = NULL;
    
25.         stack.count = 0;
    
26. 
    
27.         return TRUE;
    
28. }
    
29. 
    
30. //入栈
    
31. BOOL Push(LinkStack &stack, LinkStackPtr pStackNode) {
    
32.         //判断节点是否为空
    
33.         if (pStackNode == NULL) {
    
34.                 printf("Node doesn't exist!");
    
35.                 return FALSE;
    
36.         }
    
37. 
    
38.         //新节点入栈
    
39.         pStackNode->next = stack.top;
    
40.         stack.top = pStackNode;        //新栈顶
    
41.         stack.count++;        //节点数+1
    
42. 
    
43.         return TRUE;
    
44. }
    
45. 
    
46. //出栈
    
47. BOOL Pop(LinkStack &stack, LinkStackPtr &pStackNode) {
    
48.         //判断是否栈空
    
49.         if (stack.count == 0) {
    
50.                 printf("Stack empty!");
    
51.                 return FALSE;
    
52.         }
    
53. 
    
54.         //取出节点
    
55.         pStackNode = stack.top;
    
56.         stack.top = stack.top->next;
    
57.         pStackNode->next = NULL;
    
58.         //节点数-1
    
59.         stack.count--;
    
60. 
    
61.         return TRUE;
    
62. }
    
63. 
    
64. //创建节点
    
65. LinkStackPtr CreateNode(ElemType data) {
    
66.         //申请空间
    
67.         LinkStackPtr pNode = (LinkStackPtr)malloc(sizeof(StackNode));
    
68.         //申请失败
    
69.         if (pNode == NULL) {
    
70.                 printf("Cannot apply for enough memory.");
    
71.                 return NULL;
    
72.         }
    
73. 
    
74.         pNode->data = data;
    
75.         pNode->next = NULL;
    
76.         return pNode;
    
77. }
    
78. 
    
79. //取出节点数据
    
80. ElemType GetData(LinkStackPtr pNode) {
    
81.         return pNode->data;
    
82. }
    
83. 
    
84. int main(int argc, char** argv) {
    
85.         //初始化栈
    
86.         LinkStack stack;
    
87.         InitStack(stack);
    
88. 
    
89.         //为了方便，我就直接赋值做测试了，
    
90.         //有效性检测也省了不写了
    
91.         ElemType data[5];
    
92.         LinkStackPtr pNode[5];
    
93.         for (int i = 0; i < 5; ++i) {
    
94.                 data[i] = i;
    
95.                 pNode[i] = CreateNode(data[i]);
    
96.         }
    
97. 
    
98.         //入栈
    
99.         Push(stack, pNode[0]);
    
100.         Push(stack, pNode[1]);
     
101.         Push(stack, pNode[2]);
     
102. 
     
103.         //出栈
     
104.         LinkStackPtr pTemp = NULL;
     
105.         Pop(stack, pTemp);
     
106.         printf("%d\n", GetData(pTemp));
     
107. 
     
108.         return 0;
     
109. }

复制代码

故乡的风

里面我没怎么测试，期末考试临近，我也得复习。你可以自己测试下。用面向对象的思考方式学习数据结构，你会对数据结构有更深的理解。

故乡的风

q5603113 发表于 2012-6-12 20:13

                               
登录/注册后可看大图

可我代码对比了一下，还是找不到这种代码的好处在那里，可能我对数据结构的理解还不够深刻吧

其实我的代码也写得很一般般的。我也只是写出自己的一点理解而已，也还有很多需要学习的地方

chao_prince

1. // Stack.h
   
2. typedef int ElementType;
   
3. 
   
4. #ifndef STACK_H_
   
5. #define STACK_H_
   
6. 
   
7. // 结点的前向声明，具体实现在.c文件
   
8. struct Node;
   
9. typedef struct Node *PtrToNode;
   
10. typedef PtrToNode Stack;
    
11. 
    
12. int IsEmpty( Stack S );
    
13. Stack CreateStack( void );
    
14. void DestroyStack( Stack *S );
    
15. void MakeEmpty( Stack S );
    
16. void Push( ElementType X, Stack S );
    
17. // 返回栈顶元素
    
18. ElementType Top( Stack S );
    
19. // 只弹出栈顶元素，不返回此元素
    
20. void Pop( Stack S );
    
21. // 弹出栈顶元素，同时返回此元素
    
22. ElementType TopAndPop( Stack );
    
23. #endif

复制代码

1. // Stack.c
   
2. #include "Stack.h"
   
3. #include <stdlib.h>
   
4. #include <assert.h>
   
5. 
   
6. struct Node{
   
7.         ElementType Element;
   
8.         PtrToNode Next;
   
9. };
   
10. 
    
11. int IsEmpty( Stack S )
    
12. {
    
13.         return S->Next == NULL;
    
14. }
    
15. 
    
16. //************************************
    
17. // Method:    CreateStack
    
18. // FullName:  CreateStack
    
19. // Access:    public
    
20. // Returns:   Stack
    
21. // Qualifier: 链式堆栈，链表带头结点
    
22. // Parameter: void
    
23. //************************************
    
24. Stack CreateStack( void )
    
25. {
    
26.         Stack S;
    
27.        
    
28.         S = malloc( sizeof( struct Node ) );
    
29.         assert( S != NULL );
    
30.         S->Next = NULL;
    
31. 
    
32.         MakeEmpty( S );
    
33. 
    
34.         return S;
    
35. }
    
36. 
    
37. void MakeEmpty( Stack S )
    
38. {
    
39.         assert( S != NULL );
    
40. 
    
41.         while( !IsEmpty( S ) )
    
42.                 Pop( S );
    
43. }
    
44. 
    
45. void DestroyStack( Stack *S )
    
46. {
    
47.         MakeEmpty( *S );
    
48.         free( *S );
    
49. 
    
50.         // 将头结点释放后置为NULL，
    
51.         // 防止悬挂指针
    
52.         *S = NULL;
    
53. }
    
54. 
    
55. void Push( ElementType X, Stack S )
    
56. {
    
57.         PtrToNode TmpCell;
    
58. 
    
59.         TmpCell = malloc( sizeof( struct Node ) );
    
60.         assert( TmpCell != NULL );
    
61. 
    
62.         TmpCell->Element = X;
    
63.         TmpCell->Next = S->Next;
    
64.         S->Next = TmpCell;
    
65. }
    
66. 
    
67. ElementType Top( Stack S )
    
68. {
    
69.         // 确保S不为空栈
    
70.         assert( !IsEmpty( S ) );
    
71. 
    
72.         return S->Next->Element;
    
73. }
    
74. 
    
75. void Pop( Stack S )
    
76. {
    
77.         PtrToNode FirstCell;
    
78. 
    
79.         // 确保S不为空栈
    
80.         assert( !IsEmpty( S ) );
    
81. 
    
82.         FirstCell = S->Next;
    
83.         S->Next = FirstCell->Next;
    
84.         free( FirstCell );
    
85. }
    
86. 
    
87. ElementType TopAndPop( Stack S )
    
88. {
    
89.         PtrToNode FirstCell;
    
90.         ElementType X;
    
91. 
    
92.         // 确保S不为空栈
    
93.         assert( !IsEmpty( S ) );
    
94. 
    
95.         FirstCell = S->Next;
    
96.         X = FirstCell->Element;
    
97.         S->Next = FirstCell->Next;
    
98.         free( FirstCell );
    
99. 
    
100.         return X;
     
101. }

复制代码

1. // TestStack.c
   
2. #include "Stack.h"
   
3. #include <stdio.h>
   
4. 
   
5. int main()
   
6. {
   
7.         Stack S = NULL;
   
8. 
   
9.         S = CreateStack();
   
10. 
    
11.         Push( 520, S );
    
12.         Push( 1314, S );
    
13. 
    
14.         while( !IsEmpty(S) )
    
15.                 printf( "出栈元素是: %d\n", TopAndPop(S) );
    
16. 
    
17.         return 0;
    
18. }

复制代码