设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › C\C++交流 › 如何把链表保存到文件中并且读取？
返回列表 发新帖
查看: 926|回复: 4

[已解决]如何把链表保存到文件中并且读取？

[复制链接]
念久已
发表于 2024-12-20 14:18:32 From FishC Mobile | 显示全部楼层 |阅读模式
20鱼币

这里那里有问题啊[裂开]能运行，但是保存进去后重新读取不一样
最佳答案
月排行榜 / 总排行榜
小甲鱼的二师兄
2024-12-20 14:18:33

  2. // 链表节点的定义
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>

  7. // 定义链表节点
  8. typedef struct Node {
  9.     int data;
  10.     struct Node* next;
  11. } Node;

  13. // 创建一个新节点
  14. Node* createNode(int data) {
  15.     Node* newNode = (Node*)malloc(sizeof(Node));
  16.     if (!newNode) {
  17.         printf("内存分配失败\n");
  18.         exit(1);
  19.     }
  20.     newNode->data = data;
  21.     newNode->next = NULL;
  22.     return newNode;
  23. }

  25. // 将链表保存到文件中
  26. void saveLinkedListToFile(Node* head, const char* filename) {
  27.     FILE* file = fopen(filename, "w");
  28.     if (!file) {
  29.         printf("无法打开文件 %s\n", filename);
  30.         return;
  31.     }

  33.     Node* current = head;
  34.     while (current != NULL) {
  35.         fprintf(file, "%d\n", current->data);
  36.         current = current->next;
  37.     }

  39.     fclose(file);
  40.     printf("链表已保存到文件 %s\n", filename);
  41. }

  43. // 从文件中读取链表
  44. Node* readLinkedListFromFile(const char* filename) {
  45.     FILE* file = fopen(filename, "r");
  46.     if (!file) {
  47.         printf("无法打开文件 %s\n", filename);
  48.         return NULL;
  49.     }

  51.     Node* head = NULL;
  52.     Node* tail = NULL;
  53.     int data;

  55.     while (fscanf(file, "%d", &data) != EOF) {
  56.         Node* newNode = createNode(data);
  57.         if (head == NULL) {
  58.             head = newNode;
  59.             tail = newNode;
  60.         } else {
  61.             tail->next = newNode;
  62.             tail = newNode;
  63.         }
  64.     }

  66.     fclose(file);
  67.     printf("链表已从文件 %s 读取\n", filename);
  68.     return head;
  69. }

  71. // 打印链表
  72. void printLinkedList(Node* head) {
  73.     Node* current = head;
  74.     while (current != NULL) {
  75.         printf("%d -> ", current->data);
  76.         current = current->next;
  77.     }
  78.     printf("NULL\n");
  79. }

  81. // 释放链表
  82. void freeLinkedList(Node* head) {
  83.     Node* current = head;
  84.     while (current != NULL) {
  85.         Node* temp = current;
  86.         current = current->next;
  87.         free(temp);
  88.     }
  89. }

  91. // 主函数
  92. int main() {
  93.     // 创建一个链表
  94.     Node* head = createNode(1);
  95.     head->next = createNode(2);
  96.     head->next->next = createNode(3);

  98.     printf("原始链表: ");
  99.     printLinkedList(head);

  101.     // 保存链表到文件
  102.     const char* filename = "linked_list.txt";
  103.     saveLinkedListToFile(head, filename);

  105.     // 释放原始链表
  106.     freeLinkedList(head);

  108.     // 从文件中读取链表
  109.     head = readLinkedListFromFile(filename);

  111.     printf("从文件读取的链表: ");
  112.     printLinkedList(head);

  114.     // 释放读取的链表
  115.     freeLinkedList(head);

  117.     return 0;
  118. }
复制代码

最佳答案

小甲鱼的二师兄

查看完整内容

小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

小甲鱼的二师兄
发表于 2024-12-20 14:18:33 | 显示全部楼层    本楼为最佳答案   

  2. // 链表节点的定义
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>

  7. // 定义链表节点
  8. typedef struct Node {
  9.     int data;
  10.     struct Node* next;
  11. } Node;

  13. // 创建一个新节点
  14. Node* createNode(int data) {
  15.     Node* newNode = (Node*)malloc(sizeof(Node));
  16.     if (!newNode) {
  17.         printf("内存分配失败\n");
  18.         exit(1);
  19.     }
  20.     newNode->data = data;
  21.     newNode->next = NULL;
  22.     return newNode;
  23. }

  25. // 将链表保存到文件中
  26. void saveLinkedListToFile(Node* head, const char* filename) {
  27.     FILE* file = fopen(filename, "w");
  28.     if (!file) {
  29.         printf("无法打开文件 %s\n", filename);
  30.         return;
  31.     }

  33.     Node* current = head;
  34.     while (current != NULL) {
  35.         fprintf(file, "%d\n", current->data);
  36.         current = current->next;
  37.     }

  39.     fclose(file);
  40.     printf("链表已保存到文件 %s\n", filename);
  41. }

  43. // 从文件中读取链表
  44. Node* readLinkedListFromFile(const char* filename) {
  45.     FILE* file = fopen(filename, "r");
  46.     if (!file) {
  47.         printf("无法打开文件 %s\n", filename);
  48.         return NULL;
  49.     }

  51.     Node* head = NULL;
  52.     Node* tail = NULL;
  53.     int data;

  55.     while (fscanf(file, "%d", &data) != EOF) {
  56.         Node* newNode = createNode(data);
  57.         if (head == NULL) {
  58.             head = newNode;
  59.             tail = newNode;
  60.         } else {
  61.             tail->next = newNode;
  62.             tail = newNode;
  63.         }
  64.     }

  66.     fclose(file);
  67.     printf("链表已从文件 %s 读取\n", filename);
  68.     return head;
  69. }

  71. // 打印链表
  72. void printLinkedList(Node* head) {
  73.     Node* current = head;
  74.     while (current != NULL) {
  75.         printf("%d -> ", current->data);
  76.         current = current->next;
  77.     }
  78.     printf("NULL\n");
  79. }

  81. // 释放链表
  82. void freeLinkedList(Node* head) {
  83.     Node* current = head;
  84.     while (current != NULL) {
  85.         Node* temp = current;
  86.         current = current->next;
  87.         free(temp);
  88.     }
  89. }

  91. // 主函数
  92. int main() {
  93.     // 创建一个链表
  94.     Node* head = createNode(1);
  95.     head->next = createNode(2);
  96.     head->next->next = createNode(3);

  98.     printf("原始链表: ");
  99.     printLinkedList(head);

  101.     // 保存链表到文件
  102.     const char* filename = "linked_list.txt";
  103.     saveLinkedListToFile(head, filename);

  105.     // 释放原始链表
  106.     freeLinkedList(head);

  108.     // 从文件中读取链表
  109.     head = readLinkedListFromFile(filename);

  111.     printf("从文件读取的链表: ");
  112.     printLinkedList(head);

  114.     // 释放读取的链表
  115.     freeLinkedList(head);

  117.     return 0;
  118. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

FishC
发表于 2024-12-20 14:18:48 | 显示全部楼层
在保存链表到文件和从文件中读取链表时，确保每个节点的数据结构没有丢失至关重要。以下是一个基本的步骤，可以帮助你实现这个功能：

1. **定义链表节点：**
  1. class Node:
  2.     def __init__(self, data):
  3.         self.data = data
  4.         self.next = None
复制代码


2. **将链表保存到文件：**
   - 遍历链表，将每个节点的数据写入文件中。
   - 你可以选择用简单的文本格式或更复杂的格式（如序列化）来存储。

  1. def save_linked_list_to_file(head, filename):
  2.     with open(filename, 'w') as file:
  3.         current = head
  4.         while current:
  5.             file.write(str(current.data) + '\n')
  6.             current = current.next
复制代码


3. **从文件读取链表：**
   - 从文件中读取每一行数据，创建新的链表节点，并将其添加到链表中。

  1. def read_linked_list_from_file(filename):
  2.     with open(filename, 'r') as file:
  3.         head = None
  4.         current = None
  5.         for line in file:
  6.             data = line.strip()
  7.             new_node = Node(data)
  8.             if not head:
  9.                 head = new_node
  10.                 current = head
  11.             else:
  12.                 current.next = new_node
  13.                 current = current.next
  14.     return head
复制代码


4. **使用示例：**

  1. # 创建一个简单的链表 1 -> 2 -> 3
  2. head = Node(1)
  3. head.next = Node(2)
  4. head.next.next = Node(3)

  6. # 保存链表到文件
  7. save_linked_list_to_file(head, 'linked_list.txt')

  9. # 从文件读取链表
  10. new_head = read_linked_list_from_file('linked_list.txt')

  12. # 遍历新链表，打印数据
  13. current = new_head
  14. while current:
  15.     print(current.data)
  16.     current = current.next
复制代码


通过上述步骤，你应该可以正确地保存和读取链表。如果数据类型比较复杂，考虑使用Python的`pickle`模块进行序列化和反序列化。注意，如果使用文本格式保存，确保所有数据都可以用字符串表达，并且在读取时能够正确转换回原始数据类型。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

念久已
 楼主| 发表于 2024-12-20 14:24:12 From FishC Mobile | 显示全部楼层
FishC 发表于 2024-12-20 14:18
在保存链表到文件和从文件中读取链表时，确保每个节点的数据结构没有丢失至关重要。以下是一个基本的步骤， ...

用c语言怎么做呀
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

FishC
发表于 2024-12-20 14:24:59 | 显示全部楼层
念久已 发表于 2024-12-20 14:24
用c语言怎么做呀


在C语言中，可以通过文件操作将链表保存到文件，然后读取回来构建链表。以下是一个简单的示例程序：

1. **定义链表节点结构：**

  1. typedef struct Node {
  2.     int data;
  3.     struct Node* next;
  4. } Node;
复制代码


2. **保存链表到文件：**

  1. void saveLinkedListToFile(Node* head, const char* filename) {
  2.     FILE* file = fopen(filename, "w");
  3.     if (!file) {
  4.         printf("无法打开文件。\n");
  5.         return;
  6.     }
  7.     Node* current = head;
  8.     while (current != NULL) {
  9.         fprintf(file, "%d\n", current->data);
  10.         current = current->next;
  11.     }
  12.     fclose(file);
  13. }
复制代码


3. **从文件读取链表：**

  1. Node* readLinkedListFromFile(const char* filename) {
  2.     FILE* file = fopen(filename, "r");
  3.     if (!file) {
  4.         printf("无法打开文件。\n");
  5.         return NULL;
  6.     }

  8.     Node* head = NULL;
  9.     Node* current = NULL;

  11.     int data;
  12.     while (fscanf(file, "%d", &data) != EOF) {
  13.         Node* newNode = (Node*)malloc(sizeof(Node));
  14.         newNode->data = data;
  15.         newNode->next = NULL;

  17.         if (head == NULL) {
  18.             head = newNode;
  19.             current = head;
  20.         } else {
  21.             current->next = newNode;
  22.             current = current->next;
  23.         }
  24.     }
  25.     fclose(file);
  26.     return head;
  27. }
复制代码


4. **使用示例：**

  1. int main() {
  2.     // 创建简单链表 1 -> 2 -> 3
  3.     Node* head = (Node*)malloc(sizeof(Node));
  4.     head->data = 1;
  5.     head->next = (Node*)malloc(sizeof(Node));
  6.     head->next->data = 2;
  7.     head->next->next = (Node*)malloc(sizeof(Node));
  8.     head->next->next->data = 3;
  9.     head->next->next->next = NULL;

  11.     // 保存链表到文件
  12.     saveLinkedListToFile(head, "linked_list.txt");

  14.     // 从文件读取链表
  15.     Node* newHead = readLinkedListFromFile("linked_list.txt");

  17.     // 遍历新链表，打印数据
  18.     Node* current = newHead;
  19.     while (current != NULL) {
  20.         printf("%d ", current->data);
  21.         Node* temp = current;
  22.         current = current->next;
  23.         free(temp);  // 释放节点内存
  24.     }
  25.     printf("\n");

  27.     // 逐个释放最初分配的节点内存
  28.     current = head;
  29.     while (current != NULL) {
  30.         Node* temp = current;
  31.         current = current->next;
  32.         free(temp);
  33.     }

  35.     return 0;
  36. }
复制代码


在上述程序中，我们先定义了链表节点的结构体，然后实现了两个函数来保存和读取链表。要记得释放动态分配的内存以避免内存泄漏。请根据实际需求调整代码，例如数据类型和文件名。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-5-10 03:11

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表