好的，以下是一个家谱管理系统的设计和实现：
1. 家族成员信息的输入和保存
我们可以定义一个 `Member` 结构体来表示家族成员的信息，其中包含了姓名、出生日期、婚否、地址、健在否等属性。我们可以通过一个数组来存储所有成员的信息，或者使用文件或数据库来进行数据的持久化。
2. 树形显示家谱信息
我们可以使用树形结构来存储家谱信息，其中树的根节点表示祖先，树的叶子节点表示后代。我们可以定义一个 `TreeNode` 结构体来表示家族成员节点，其中包含了 `Member` 数据和指向父节点和子节点的指针。
在显示家谱信息时，我们可以通过递归遍历整棵树，并在每个节点处输出该节点的成员信息和子节点的信息。
3. 显示第 n 代所有人的信息
我们可以通过递归遍历树来实现此功能。假设我们要显示第 n 代所有人的信息，我们可以从根节点开始遍历，对于每个节点，如果它的深度为 n，就将它的成员信息输出，并递归遍历它的子节点（深度为 n-1）。
4. 按照姓名查询成员信息
我们可以在 `Member` 结构体中添加一个 `parent` 指针，表示该成员的父节点。在输入成员信息时，如果该成员有父亲或母亲，就将其父亲或母亲的 `parent` 指针指向该成员。
在按照姓名查询成员信息时，我们可以从根节点开始遍历整棵树，并在每个节点处比较其成员信息的姓名和查询的姓名是否相同。如果相同，则输出该成员的信息，并递归输出其父节点和子节点的信息。
5. 按照出生日期查询家族成员名单
我们可以在 `Member` 结构体中添加一个 `birthdate` 属性，表示该成员的出生日期。在输入成员信息时，我们可以要求用户输入成员的出生日期，并将其保存到 `Member` 结构体中。
在按照出生日期查询家族成员名单时，我们可以从根节点开始遍历整棵树，并在每个节点处比较其成员信息的出生日期和查询的出生日期是否相同。如果相同，则输出该成员的信息，并递归输出其父节点和子节点的信息。
6. 确定两个人的关系
我们可以通过递归遍历树来查找两个人之间的关系。假设我们要确定 A 和 B 之间的关系，我们可以先找到 A 和 B 的最近公共祖先节点 C，然后根据 C 节点与 A、B 节点的关系，确定 A 和 B 之间的关系。
例如，如果 C 是 A 的父亲或母亲，而且 C 也是 B 的父亲或母亲，那么 A 和 B 是兄弟姐妹。如果 C 是 A 的祖父母，那么 A 是 B 的叔叔或姑婆，B 是 A 的侄子或侄女，等等。
7. 修改某位家族成员信息
我们可以按照姓名查询到要修改的家族成员，然后让用户输入新的成员信息，将其覆盖原有的成员信息。
8. 按出生日期对家族中所有人排序
我们可以将所有成员的信息存储到一个数组中，然后对数组进行排序，最后输出排序后的成员信息。
以下是一个基于上述设计的家谱管理系统的 C 语言代码示例：
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_NAME_LEN 20
#define MAX_ADDRESS_LEN 50
#define MAX_MEMBERS 20
typedef struct _Member {
char name[MAX_NAME_LEN];
char birthdate[11];
int married;
char address[MAX_ADDRESS_LEN];
int alive;
struct _Member *parent;
} Member;
typedef struct _TreeNode {
Member data;
struct _TreeNode *father;
struct _TreeNode *mother;
} TreeNode;
Member create_member() {
Member member;
printf("请输入成员姓名：");
scanf("%s", member.name);
printf("请输入成员出生日期（格式为 xxxx-xx-xx）：");
scanf("%s", member.birthdate);
printf("该成员是否已婚（0-未婚，1-已婚）：");
scanf("%d", &member.married);
printf("请输入成员地址：");
scanf("%s", member.address);
printf("该成员是否健在（0-已故，1-健在）：");
scanf("%d", &member.alive);
return member;
}
void add_child(TreeNode *parent, TreeNode *child) {
if (parent->father == NULL) {
parent->father = child;
child->data.parent = parent->data.parent;
} else {
parent->mother = child;
child->data.parent = parent->data.parent;
}
}
TreeNode *create_tree_node(Member member) {
TreeNode *node = (TreeNode *) malloc(sizeof(TreeNode));
node->data = member;
node->father = NULL;
node->mother = NULL;
return node;
}
void input_members(TreeNode *root) {
Member member = create_member();
TreeNode *node = create_tree_node(member);
add_child(root, node);
int n;
printf("请输入该成员的子女数量：");
scanf("%d", &n);
for (int i = 0; i < n; i++) {
input_members(node);
}
}
void print_member(Member member) {
printf("姓名：%s\t出生日期：%s\t婚否：%s\t地址：%s\t健在否：%s\n",
member.name, member.birthdate, member.married ? "已婚" : "未婚",
member.address, member.alive ? "健在" : "已故");
}
void print_tree(TreeNode *root, int depth) {
if (root == NULL) {
return;
}
for (int i = 0; i < depth; i++) {
printf(" ");
}
print_member(root->data);
print_tree(root->father, depth + 1);
print_tree(root->mother, depth + 1);
}
void print_generation(TreeNode *root, int depth, int n) {
if (root == NULL) {
return;
}
if (depth == n) {
print_member(root->data);
}
print_generation(root->father, depth + 1, n);
print_generation(root->mother, depth + 1, n);
}
TreeNode *find_member(TreeNode *root, char *name) {
if (root == NULL) {
return NULL;
}
if (strcmp(root->data.name, name) == 0) {
return root;
}
TreeNode *node = find_member(root->father, name);
if (node == NULL) {
node = find_member(root->mother, name);
}
return node;
}
void find_member_by_name(TreeNode *root, char *name) {
TreeNode *node = find_member(root, name);
if (node == NULL) {
printf("找不到该成员！\n");
} else {
print_member(node->data);
if (node->data.parent != NULL) {
printf("父亲：");
print_member(node->data.parent->data);
}
if (node->data.alive) {
if (node->father != NULL) {
printf("儿子：");
print_member(node->father->data);
}
if (node->mother != NULL) {
printf("女儿：");
print_member(node->mother->data);
}
}
}
}
void find_member_by_birthdate(TreeNode *root, char *birthdate) {
if (root == NULL) {
return;
}
if (strcmp(root->data.birthdate, birthdate) == 0) {
print_member(root->data);
}
find_member_by_birthdate(root->father, birthdate);
find_member_by_birthdate(root->mother, birthdate);
}
int get_depth(TreeNode *root, TreeNode *node) {
if (root == NULL) {
return -1;
}
if (root == node) {
return 0;
}
int depth = -1;
depth = get_depth(root->father, node);
if (depth == -1) {
depth = get_depth(root->mother, node);
}
if (depth != -1) {
depth++;
}
return depth;
}
void find_relationship(TreeNode *root, char *name1, char *name2) {
TreeNode *node1 = find_member(root, name1);
TreeNode *node2 = find_member(root, name2);
if (node1 == NULL || node2 == NULL) {
printf("找不到该成员！\n");
return;
}
int depth1 = get_depth(root, node1);
int depth2 = get_depth(root, node2);
int diff = depth1 - depth2;
if (diff > 0) {
for (int i = 0; i < diff; i++) {
printf("爷爷/奶奶 ");
}
printf("父亲/母亲 ");
} else if (diff < 0) {
for (int i = 0; i < -diff; i++) {
printf("孙子/孙女 ");
}
printf("儿子/女儿 ");
} else {
printf("兄弟姐妹 ");
}
}
void modify_member(TreeNode *root, char *name) {
TreeNode *node = find_member(root, name);
if (node == NULL) {
printf("找不到该成员！\n");
return;
}
printf("请输入新的成员信息：\n");
node->data = create_member();
}
int compare_member(const void *p1, const void *p2) {
Member *m1 = (Member *) p1;
Member *m2 = (Member *) p2;
return strcmp(m1->birthdate, m2->birthdate);
}
void sort_by_birthdate(Member *members, int n) {
qsort(members, n, sizeof(Member), compare_member);
}
int main() {
Member root_member;
strcpy(root_member.name, "Tom");
strcpy(root_member.birthdate, "1901-01-01");
root_member.married = 1;
strcpy(root_member.address, "北京市朝阳区");
root_member.alive = 1;
TreeNode *root = create_tree_node(root_member);
input_members(root);
while (1) {
printf("\n");
printf("1. 显示家谱\n");
printf("2. 显示第n代所有人的信息\n");
printf("3. 按姓名查询成员信息\n");
printf("4. 按出生日期查询家族成员名单\n");
printf("5. 确定两个人的关系\n");
printf("6. 修改某位家族成员信息\n");
printf("7. 按出生日期对家族中所有人排序\n");
printf("0. 退出程序\n");
printf("请选择操作：");
int choice;
scanf("%d", &choice);
printf("\n");
if (choice == 0) {
扫一扫
174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
