[已解决]用链表的方式编程实现：在键盘上一次输入5个整数，然后将它们反序输出

VaeSummerTime

用链表的方式实现：在键盘上一次输入5个整数，然后将它们反序输出
效果如下：
--------------------------------------------------------------------------------------------------
请输入5个整数：11 22 33 44 55
反向输出：55 44 33 22 11

刚开始接触链表，有些不熟悉，可以看下源码吗
大佬们别复制粘贴网上的代码可以吗，运行一堆报错的

最佳答案

月排行榜 / 总排行榜

傻眼貓咪

2021-12-17 10:45:18

C 代码：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. struct Node{
   
5.         int data;
   
6.         struct Node* next;
   
7. };
   
8. 
   
9. int main(){
   
10.         int N;
    
11.         struct Node *head = NULL, *tail = NULL;
    
12.         scanf("%d", &N);
    
13.         while(N--){
    
14.                 tail = head;
    
15.                 head = (struct Node*)malloc(sizeof(struct Node));
    
16.                 scanf("%d", &head->data);
    
17.                 head->next = tail;
    
18.         }
    
19.        
    
20.         for(; head; head = head->next) printf("%d ", head->data);
    
21.         return 0;
    
22. }

复制代码

跳转到最佳答案楼层

jhq999

1. typedef struct LinkList
   
2. {
   
3.    int data;
   
4.    LinkList *next;
   
5. }LLST,*pLLST;
   
6. int main()
   
7. {
   
8.     pLLST head=NULL,tmp=NULL;
   
9.     int count=0,i=0;
   
10.     scanf("%d",&count);
    
11.     for(i=0;i<count;i++)
    
12.     {
    
13.         tmp=head;
    
14.         head=new LLST;
    
15.         head->next=tmp;
    
16.         scanf("%d",&head->data);
    
17.      }
    
18.    
    
19.     while(head)
    
20.     {
    
21.           printf("%d   ",head->data);
    
22.           tmp=head;
    
23.           head=head->next;
    
24.           delete tmp;
    
25.      }
    
26.     return 0;
    
27. }

复制代码

梦回连营

1. #include <iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. struct Node
   
6. {
   
7.     int val;
   
8.     Node* next;
   
9.     Node(int val = 0, Node* next = nullptr): val(val), next(next) {};
   
10. };
    
11. 
    
12. int main(void) {
    
13.     Node* first = new Node();
    
14.     cout << "enter five num: ";
    
15.     for (int i = 0; i < 5; i++) {
    
16.         int a; cin >> a;
    
17.         Node* second = new Node(a);
    
18.         Node* t;
    
19.         
    
20.         t = first;
    
21.         first = second;
    
22.         first->next = t;
    
23.     }
    
24. 
    
25.     while (first->next) {
    
26.         cout << first->val << ' ';
    
27.         first = first->next;
    
28.     }
    
29. }

复制代码

人造人

main.c

1. #include "list.h"
   
2. #include <stdio.h>
   
3. 
   
4. void output(const list_t *list, size_t index) {
   
5.     if(index >= list_size(list)) return;
   
6.     output(list, index + 1);
   
7.     int temp; list_get(list, index, &temp, sizeof(temp));
   
8.     printf("%d ", temp);
   
9. }
   
10. 
    
11. int main(void) {
    
12.     list_t *list = list_init();
    
13.     for(size_t i = 0; i < 5; ++i) {
    
14.         int temp; scanf("%d", &temp);
    
15.         list_append(list, &temp, sizeof(temp));
    
16.     }
    
17.     output(list, 0); puts("");
    
18.     list_deinit(list);
    
19.     return 0;
    
20. }
    

复制代码

list.h

1. #ifndef _LIST_H_
   
2. #define _LIST_H_
   
3. 
   
4. #include <stddef.h>
   
5. #include <stdbool.h>
   
6. 
   
7. struct list_node_tag {
   
8.     void *data; size_t size;
   
9.     struct list_node_tag *next;
   
10. };
    
11. 
    
12. typedef struct {
    
13.     struct list_node_tag *head;
    
14.     size_t size;
    
15. } list_t;
    
16. 
    
17. list_t *list_init(void);
    
18. void list_deinit(list_t *list);
    
19. bool list_clean(list_t *list);
    
20. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
21. bool list_delete(list_t *list, size_t index);
    
22. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
23. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
24. bool list_append(list_t *list, const void *data, size_t size);
    
25. size_t list_size(const list_t *list);
    
26. bool list_empty(const list_t *list);
    
27. 
    
28. #endif
    

复制代码

list.c

1. #include "list.h"
   
2. #include <stdlib.h>
   
3. #include <memory.h>
   
4. 
   
5. list_t *list_init(void) {
   
6.     list_t *list = malloc(sizeof(*list));
   
7.     if(!list) return NULL;
   
8.     list->head = NULL;
   
9.     list->size = 0;
   
10.     return list;
    
11. }
    
12. 
    
13. void list_deinit(list_t *list) {
    
14.     if(!list) return;
    
15.     list_clean(list);
    
16.     free(list);
    
17. }
    
18. 
    
19. bool list_clean(list_t *list) {
    
20.     if(!list) return false;
    
21.     while(!list_empty(list)) list_delete(list, 0);
    
22.     return true;
    
23. }
    
24. 
    
25. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
    
26.     if(!list) return false;
    
27.     if(list_size(list) < index) return false;
    
28.     if(!data) return false;
    
29.     struct list_node_tag **current = &list->head;
    
30.     while(index--) current = &(*current)->next;
    
31.     struct list_node_tag *node = malloc(sizeof(*node));
    
32.     if(!node) return false;
    
33.     node->data = malloc(size);
    
34.     if(!node->data) {free(node); return false;}
    
35.     memcpy(node->data, data, size);
    
36.     node->size = size;
    
37.     node->next = *current;
    
38.     *current = node;
    
39.     ++list->size;
    
40.     return true;
    
41. }
    
42. 
    
43. bool list_delete(list_t *list, size_t index) {
    
44.     if(!list) return false;
    
45.     if(list_size(list) <= index) return false;
    
46.     struct list_node_tag **current = &list->head;
    
47.     while(index--) current = &(*current)->next;
    
48.     struct list_node_tag *temp = *current;
    
49.     *current = temp->next;
    
50.     free(temp->data); free(temp);
    
51.     --list->size;
    
52.     return true;
    
53. }
    
54. 
    
55. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
    
56.     if(!list) return false;
    
57.     if(list_size(list) <= index) return false;
    
58.     if(!data) return false;
    
59.     struct list_node_tag *const *current = &list->head;
    
60.     while(index--) current = &(*current)->next;
    
61.     struct list_node_tag *temp = *current;
    
62.     if(temp->size > size) return false;
    
63.     memcpy(data, temp->data, temp->size);
    
64.     return true;
    
65. }
    
66. 
    
67. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
    
68.     bool res = list_delete(list, index);
    
69.     return res ? list_insert(list, index, data, size) : res;
    
70. }
    
71. 
    
72. bool list_append(list_t *list, const void *data, size_t size) {
    
73.     if(!list) return false;
    
74.     return list_insert(list, list_size(list), data, size);
    
75. }
    
76. 
    
77. size_t list_size(const list_t *list) {
    
78.     if(!list) return 0;
    
79.     return list->size;
    
80. }
    
81. 
    
82. bool list_empty(const list_t *list) {
    
83.     if(!list) return true;
    
84.     return list_size(list) == 0;
    
85. }
    

复制代码

1. $ gcc-debug -o main main.c list.c
   
2. $ ./main
   
3. 11 22 33 44 55
   
4. 55 44 33 22 11
   
5. $

复制代码

人造人

main.c

1. #include "stack.h"
   
2. #include <stdio.h>
   
3. 
   
4. int main(void) {
   
5.     stack_t *stack = stack_init();
   
6.     for(size_t i = 0; i < 5; ++i) {
   
7.         int temp; scanf("%d", &temp);
   
8.         stack_push(stack, &temp, sizeof(temp));
   
9.     }
   
10.     while(!stack_empty(stack)) {
    
11.         int temp; stack_top(stack, &temp, sizeof(temp));
    
12.         stack_pop(stack);
    
13.         printf("%d ", temp);
    
14.     }
    
15.     puts("");
    
16.     stack_deinit(stack);
    
17.     return 0;
    
18. }
    

复制代码

stack.h

1. #ifndef _STACK_H_
   
2. #define _STACK_H_
   
3. 
   
4. #include <stddef.h>
   
5. #include <stdbool.h>
   
6. 
   
7. struct stack_node_tag {
   
8.     void *data;
   
9.     size_t size;
   
10.     struct stack_node_tag *next;
    
11. };
    
12. 
    
13. typedef struct {
    
14.     struct stack_node_tag *head;
    
15.     size_t size;
    
16. } stack_t;
    
17. 
    
18. stack_t *stack_init(void);
    
19. void stack_deinit(stack_t *stack);
    
20. bool stack_clean(stack_t *stack);
    
21. bool stack_push(stack_t *stack, const void *data, size_t size);
    
22. bool stack_pop(stack_t *stack);
    
23. bool stack_top(const stack_t *stack, void *data, size_t size);
    
24. size_t stack_size(const stack_t *stack);
    
25. bool stack_empty(const stack_t *stack);
    
26. 
    
27. #endif
    

复制代码

stack.c

1. #include "stack.h"
   
2. #include <stdlib.h>
   
3. #include <memory.h>
   
4. 
   
5. stack_t *stack_init(void) {
   
6.     stack_t *stack = malloc(sizeof(*stack));
   
7.     if(!stack) return NULL;
   
8.     stack->head = NULL;
   
9.     stack->size = 0;
   
10.     return stack;
    
11. }
    
12. 
    
13. void stack_deinit(stack_t *stack) {
    
14.     if(!stack) return;
    
15.     stack_clean(stack);
    
16.     free(stack);
    
17. }
    
18. 
    
19. bool stack_clean(stack_t *stack) {
    
20.     if(!stack) return false;
    
21.     while(!stack_empty(stack)) stack_pop(stack);
    
22.     return true;
    
23. }
    
24. 
    
25. bool stack_push(stack_t *stack, const void *data, size_t size) {
    
26.     if(!stack) return false;
    
27.     if(!data) return false;
    
28.     struct stack_node_tag *node = malloc(sizeof(*node));
    
29.     if(!node) return false;
    
30.     node->data = malloc(size);
    
31.     if(!node->data) {free(node); return false;}
    
32.     memcpy(node->data, data, size);
    
33.     node->size = size;
    
34.     node->next = stack->head;
    
35.     stack->head = node;
    
36.     ++stack->size;
    
37.     return true;
    
38. }
    
39. 
    
40. bool stack_pop(stack_t *stack) {
    
41.     if(!stack) return false;
    
42.     if(stack_empty(stack)) return false;
    
43.     struct stack_node_tag *temp = stack->head;
    
44.     stack->head = temp->next;
    
45.     free(temp->data); free(temp);
    
46.     --stack->size;
    
47.     return true;
    
48. }
    
49. 
    
50. bool stack_top(const stack_t *stack, void *data, size_t size) {
    
51.     if(!stack) return false;
    
52.     if(!data) return false;
    
53.     if(stack_empty(stack)) return false;
    
54.     struct stack_node_tag *temp = stack->head;
    
55.     if(temp->size > size) return false;
    
56.     memcpy(data, temp->data, temp->size);
    
57.     return true;
    
58. }
    
59. 
    
60. size_t stack_size(const stack_t *stack) {
    
61.     if(!stack) return 0;
    
62.     return stack->size;
    
63. }
    
64. 
    
65. bool stack_empty(const stack_t *stack) {
    
66.     if(!stack) return true;
    
67.     return stack_size(stack) == 0;
    
68. }
    

复制代码

1. $ gcc-debug -o main main.c stack.c
   
2. $ ./main
   
3. 11 22 33 44 55
   
4. 55 44 33 22 11
   
5. $

复制代码

傻眼貓咪

C 代码：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. struct Node{
   
5.         int data;
   
6.         struct Node* next;
   
7. };
   
8. 
   
9. int main(){
   
10.         int N;
    
11.         struct Node *head = NULL, *tail = NULL;
    
12.         scanf("%d", &N);
    
13.         while(N--){
    
14.                 tail = head;
    
15.                 head = (struct Node*)malloc(sizeof(struct Node));
    
16.                 scanf("%d", &head->data);
    
17.                 head->next = tail;
    
18.         }
    
19.        
    
20.         for(; head; head = head->next) printf("%d ", head->data);
    
21.         return 0;
    
22. }

复制代码