1.栈的顺序存储

    1. #include<stdio.h>
    2. #include<stdlib.h> 
    3. #define MaxSize 100   
    4. typedef int ElementType;  
    5. typedef struct SNode *Stack;
    6. struct SNode
    7. {
    8.     ElementType Data[MaxSize];   
    9.     int Top; 
    10. }; 
    11. Stack S;
    13. Stack CreateStack();  
    14. bool IsFull(Stack S); 
    15. bool IsEmpty(Stack S);   
    16. void Push(Stack S,ElementType item);   
    17. ElementType Pop(Stack S);   
    19. int main(void)
    20. {
    21.     S = CreateStack();
    22.     printf("5入栈\n");
    23.     Push(S,5);
    24.     printf("7入栈\n");
    25.     Push(S,7);
    26.     printf("66入栈\n");
    27.     Push(S,66);
    28.     printf("44入栈\n");
    29.     Push(S,44);
    30.     printf("%d出栈\n",Pop(S));
    31.     printf("%d出栈\n",Pop(S));
    32.     printf("%d出栈\n",Pop(S));
    33.     printf("%d出栈\n",Pop(S));
    34.     if(IsEmpty(S))
    35.     {
    36.         printf("堆栈空");
    37.     }
    38.     return 0;
    39. }
    41. Stack CreateStack()
    42. {
    43.     S = (Stack)malloc(sizeof(struct SNode));
    44.     S->Top = -1;
    45.     return S;
    46. } 
    48. bool IsFull(Stack S)
    49. {
    50.     return (S->Top == MaxSize-1);
    51. }
    53. bool IsEmpty(Stack S)
    54. {
    55.     return (S->Top == -1); 
    56. } 
    58. void Push(Stack S,ElementType item)
    59. {
    60.     if(IsFull(S))
    61.     {   
    62.         printf("堆栈满");
    63.         return;
    64.     }else
    65.     {
    66.         S->Top++;   
    67.         S->Data[S->Top] = item;   
    68.         return;
    69.     }
    70. }
    72. ElementType Pop(Stack S)
    73. {
    74.     if(IsEmpty(S))
    75.     {
    76.         printf("堆栈空");
    77.         return -1;
    78.     }
    79.     else
    80.     {
    81.         ElementType val = S->Data[S->Top];  
    82.         S->Top--;  
    83.         return val;
    84.     }
    85. }

    2.栈的链式存储

    1. #include <stdio.h>
    2. #include <stdlib.h>
    4. struct SNode
    5. {
    6.     int Data;
    7.     struct SNode *Next;
    8. }; 
    9. typedef struct SNode *Stack;
    10. Stack S;
    12. Stack CreateStack();
    13. bool IsEmpty(Stack S);
    14. void Push(Stack S,int item);
    15. int Pop( Stack S );
    17. int main(void)
    18. {
    19.     S = CreateStack();
    20.     printf("5入栈\n");
    21.     Push(S,5);
    22.     printf("7入栈\n");
    23.     Push(S,7);
    24.     printf("66入栈\n");
    25.     Push(S,66);
    26.     printf("44入栈\n");
    27.     Push(S,44);
    28.     printf("%d出栈\n",Pop(S));
    29.     printf("%d出栈\n",Pop(S));
    30.     printf("%d出栈\n",Pop(S));
    31.     printf("%d出栈\n",Pop(S));
    32.     if(IsEmpty(S))
    33.     {
    34.         printf("堆栈空");
    35.     }
    36.     return 0;
    37. }
    42. Stack CreateStack()
    43. {
    44.     Stack S;
    45.     S = (Stack)malloc(sizeof(struct SNode));
    46.     S->Next = NULL;
    47.     return S;
    48. }
    50. bool IsEmpty(Stack S)
    51. {
    52.     return (S->Next == NULL);
    53. }
    55. void Push(Stack S,int item)
    56. {
    57.     Stack tmp;
    58.     tmp = (Stack)malloc(sizeof(struct SNode));
    59.     tmp->Data = item;
    60.     tmp->Next = S->Next;   
    61.     S->Next = tmp;
    62. } 
    64. int Pop( Stack S )
    65. {
    66.  Stack Firstcell;
    67.  int Toptmp;
    68.     if ( IsEmpty(S) )
    69.     {
    70.     printf("栈空\n");
    71.     return -1;
    72.     }
    73.  Firstcell = S->Next;
    74.  S->Next = Firstcell->Next;
    75.  Toptmp = Firstcell->Data;
    76.  free(Firstcell);
    77.  return Toptmp;
    78. }