22 链栈

1，定义一个链栈，并压入一个元素

 1 //定义一个链栈，并压入一个元素
 2 
 3 /*
 4 #include<stdio.h>
 5 #include<stdlib.h>
 6 
 7 //定义链栈结点结构
 8 typedef struct LinkStackNode {
 9     int data;
10     struct LinkNode* next;
11 }LSNode;
12 
13 //进栈
14 void push(LSNode* LS, int elem) {
15     //将 elem 压入栈 LS 中
16     LSNode* new_node = (LSNode*)malloc(sizeof(LSNode)); //创建一个结点
17     if (new_node == NULL) {
18         printf("创建链栈结点失败
");
19         exit(0);
20     }
21     else {
22         new_node->data = elem;
23         new_node->next = LS->next; //给新结点的指针域赋值，新结点指向当前栈顶结点指向的下一个结点
24         LS = new_node; //新结点成为新的栈顶结点
25         printf("将%d压入链栈后，栈顶元素是:%d
", elem, LS->data);
26     }
27 
28 }
29 void main() {
30     LSNode* mystack = (LSNode*)malloc(sizeof(LSNode));
31     push(mystack, 1);
32     push(mystack, 2);
33 }
34 */

2，初始化压入10个元素进栈，并遍历打印出链栈中的全部元素

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 //定义链栈结点结构
 5 typedef struct LinkStackNode {
 6     int data;
 7     struct LinkStackNode* next;
 8 }LSNode;
 9 
10 //进栈
11 LSNode* push(LSNode* LS) {  //LS是栈顶结点
12     
13     for (int i = 0; i < 10; i++) {
14         LSNode* new_node = (LSNode*)malloc(sizeof(LSNode)); //创建一个结点
15 
16         if (new_node == NULL) {
17             printf("创建链栈结点失败
");
18             exit(0);
19         }
20         else {
21             new_node->data = i;
22             new_node->next = LS; //给新结点的指针域赋值，新结点指向当前栈顶结点
23             LS = new_node; //新结点成为新的栈顶结点
24             //printf("将%d压入链栈后，栈顶元素是:%d
", i, LS2->data);
25         }
26     }
27     return LS;
28 }
29 
30 //遍历打印出栈中的全部元素
31 void showStack(LSNode* LS) {
32     printf("链栈中的元素是:
");
33     LSNode* tmp;
34     for (tmp = LS; tmp != NULL; tmp = tmp->next) { //遍历时，注意tmp!=NULL,不是 tmp->next!=NULL，前者可以遍历到栈底结点，后者栈底结点遍历不到
35         printf("%d  ", tmp->data);
36     }
37 }
38 
39 void main() {
40     LSNode* mystack = NULL;
41     mystack = push(mystack);
42     showStack(mystack);
43     
44 }

3，出栈

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

//定义链栈结点结构
typedef struct LinkStackNode {
    int data;
    struct LinkStackNode* next;
}LSNode;

//进栈
LSNode* push(LSNode* LS) {  //LS是栈顶结点

    for (int i = 0; i < 10; i++) {
        LSNode* new_node = (LSNode*)malloc(sizeof(LSNode)); //创建一个结点

        if (new_node == NULL) {
            printf("创建链栈结点失败
");
            exit(0);
        }
        else {
            new_node->data = i;
            new_node->next = LS; //给新结点的指针域赋值，新结点指向当前栈顶结点
            LS = new_node; //新结点成为新的栈顶结点
            //printf("将%d压入链栈后，栈顶元素是:%d
", i, LS2->data);
        }
    }
    return LS;
}

//遍历打印出栈中的全部元素
void showStack(LSNode* LS) {
    printf("链栈中的元素是:
");
    LSNode* tmp;
    for (tmp = LS; tmp != NULL; tmp = tmp->next) { //遍历时，注意tmp!=NULL,不是 tmp->next!=NULL，前者可以遍历到栈底结点，后者栈底结点遍历不到
        printf("%d  ", tmp->data);
    }
    printf("
");
}

//出栈
void pop(LSNode* LS) {
    LSNode* tmp = LS;
    LS = tmp->next;
    printf("出栈元素是:%d
", tmp->data);
    free(tmp);
    printf("栈顶元素是:%d
", LS->data);
}


void main() {
    LSNode* mystack = NULL;
    mystack = push(mystack);
    showStack(mystack);
    pop(mystack);
}

从栈顶到栈底依次出栈：

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 //定义链栈结点结构
 5 typedef struct LinkStackNode {
 6     int data;
 7     struct LinkStackNode* next;
 8 }LSNode;
 9 
10 //进栈
11 LSNode* push(LSNode* LS) {  //LS是栈顶结点
12 
13     for (int i = 0; i < 10; i++) {
14         LSNode* new_node = (LSNode*)malloc(sizeof(LSNode)); //创建一个结点
15 
16         if (new_node == NULL) {
17             printf("创建链栈结点失败
");
18             exit(0);
19         }
20         else {
21             new_node->data = i;
22             new_node->next = LS; //给新结点的指针域赋值，新结点指向当前栈顶结点
23             LS = new_node; //新结点成为新的栈顶结点
24             //printf("将%d压入链栈后，栈顶元素是:%d
", i, LS2->data);
25         }
26     }
27     return LS;
28 }
29 
30 //遍历打印出栈中的全部元素
31 void showStack(LSNode* LS) {
32     printf("链栈中的元素是:
");
33     LSNode* tmp;
34     for (tmp = LS; tmp != NULL; tmp = tmp->next) { //遍历时，注意tmp!=NULL,不是 tmp->next!=NULL，前者可以遍历到栈底结点，后者栈底结点遍历不到
35         printf("%d  ", tmp->data);
36     }
37     printf("
");
38 }
39 
40 //出栈
41 void pop(LSNode* LS) {
42     while (LS != NULL) {
43         LSNode* tmp = LS;
44         LS = tmp->next;
45         printf("出栈元素是:%d
", tmp->data);
46         free(tmp);
47         printf("栈顶元素是:%d
", LS->data);
48     }
49 }
50 
51 
52 void main() {
53     LSNode* mystack = NULL;
54     mystack = push(mystack);
55     showStack(mystack);
56     pop(mystack);
57 }