C语言：课程设计《通讯录管理系统》（详细内容、心得体会）

╰+哭是因爲堅強的太久メ 2023-01-02 13:24 135阅读 0赞

# C语言：课程设计《通讯录管理系统》 #

操作系统为 Win 10，设计环境 Visual Studio 2019

--------------------

**目录**

C语言：课程设计《通讯录管理系统》

前言

一、需求分析

二、总体设计

三、详细设计

1，数据信息

2，模块设计

1）新建联系人模块

2）遍历模块

3）查询模块

4）定向删除模块

5）修改模块

6）排序模块

7）清空模块

四、总结及分析

程序代码

--------------------

# 前言 #

本文仅供学习交流，未经允许请勿转载。

--------------------

# 一、需求分析 #

实现简单的通讯录信息管理，系统要求以菜单方式工作，因而根据题目要求，提供键盘式选择菜单实现功能选择，通讯录信息包括编号、姓名、年龄、性别、手机号等。通讯录信息采用链表保存，提供节点的输入、输出、查询、修改等操作；要实现通讯录信息的查询，则要提供查找功能（包括按编号查询、姓名查询和手机号查询三种查询方式）；要实现通讯录信息的删除、修改、清空，则要提供节点的删除 、修改功能。

1.系统以菜单方式工作。

2.通讯录信息录入功能。

3.通讯录信息浏览功能 。

4.通讯录信息查询功能。

5.通讯录信息删除功能。

6.通讯录修改功能。

7.通讯录联系人排序功能。

8.通讯录清空功能。

--------------------

# 二、**总体设计** #

根据上面的需求分析,可以将这个系统设计分为以下模块：新建联系人模块、遍历模块、查询模块、定向删除模块、修改模块、排序模块、清空模块。

下面为本次通讯录管理系统的程序框图，如下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMzIzNTIw_size_16_color_FFFFFF_t_70][]

#  #

--------------------

# 三、详细设计 #

**主要思想****：**

根据动态链表的特性来实现联系人的“增删改销”，从主菜单分支出来不同的功能，结构体中统一使用字符串方便后续调用大量数据保持格式正确。

在定向删除模块中，通过对节点的头地址和尾地址的修改实现节点的删除（清空模块亦如此）。

在排序模块中，因为直接使用链表排序难度很大，因此选择将节点放入相同结构的数组里面，改变不同节点的数组下标，然后调用数组的方式实现排序输出。

在查询模块中，主要是调用节点数据，然后与输入值比较（不相同就换下一个节点比较直到数据相同，返还对应节点的地址），最后打印出来。

在修改模块中，比较简单，依靠查询模块找到指定联系人的节点然后直接修改。

## 1，数据信息 ##

编码、姓名、年龄、性别、电话、住址。

建立通讯录结构体，结构体成员包括：编号（唯一性且不可修改）、姓名、年龄、性别、电话、住址。

typedef struct Node
    {
    	int id;//编号
    	char name[20];//姓名
    	char age[20];//年龄
    	char sex[20];//性别
    	char phone[20];//手机号
    	char address[20];//住址
    	struct Node* pNext;
    }Node;

## 2，模块设计 ##

新建联系人模块：输入联系人的姓名、性别、手机号以及其它的一些通讯的相关信息，通过void AddNodeList()函数来实现。

遍历模块：浏览所有联系人的相关信息，通过自己定义的void ScanList()函数与void print(Node\* pTemp)函数来实现。

查询模块：可以按联系人姓名、编号、手机号来查询联系人的相关信息，通过自己定义的void Select()函数、Node\* SelectNode1(char xm\[20\])函数 、Node\* SelectNode2(int id)函数、Node\* SelectNode3(char phone\[20\])函数来实现。

定向删除模块：输入姓名来定位所要删除的节点地址，并完成节点的删除，通过自己定义的 void DeleteListRand() 函数，void DeleteListHead()函数，void DeleteListTail()和 Node\* SelectNode1(char xm\[20\])函数 、Node\* SelectNode2(int id)函数、Node\* SelectNode3(char phone\[20\])函数来实现。

排序模块：选择以年龄、编号、姓名、手机号来进行通讯录排序，通过自己定义void SortList()函数来实现。

清空模块：清空所有的通讯录信息，通过自己定义的void FreeList()函数来实现。

修改模块：通过姓名或者手机号锁定指定联系人，再选择下一项信息。通过自己定义的void change()函数来实现。

### 1）新建联系人模块 ###

根据数据结构定义，按顺序输入新节点的相关值，通过调整每个节点的首尾指针地址，实现那动态链表。

void AddNodeList()
    {
    	//创建一个节点
    	 Node* pTemp = (Node*)malloc(LEN);
    	//节点数据赋值
    	 printf("编号为%d\n", idnumber);
    	pTemp->id = idnumber;
    	printf("请输入姓名：");
    	scanf("%s", pTemp->name);
    	printf("\n");
    	printf("请输入年龄：");
    	scanf("%s", pTemp->age);
    	printf("\n");
    	printf("请输入性别：");
    	scanf("%s", pTemp->sex);
    	printf("\n");
    	printf("请输入手机号：");
    	scanf("%s", pTemp->phone);
    	printf("\n");
    	printf("请输入住址：");
    	scanf("%s", pTemp->address);
    	printf("\n");
    	pTemp->pNext = NULL;
    	//链接
    	if (NULL == phead)
    	{
    		phead = pTemp;
    		pend = pTemp;
    	}
    	else
    	{
    		pend->pNext = pTemp;
    		pend = pTemp;
    	}
    	system("pause");
    	system("cls");
    }

### 2）遍历模块 ###

借助动态链表“首尾相连”的特点，实现节点的顺序输出。为实现模块化，特将打印结构独立出来为函数。这样做的优点在于，其他模块函数也可以调用它，从而减少编程工作量，提升程序设计的合理性。

void ScanList()
    {
    	if (phead == NULL) {
    		printf("无任何联系人。\n");
    	} return;
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		print(pTemp);
    		pTemp = pTemp->pNext;
    	}
    	system("pause");
    	system("cls");
    }
    
    void print(Node* pTemp) {
    	 if (pTemp == NULL) {
    		 printf("\n--------------------您要查找的联系人不存在!--------------------------------\n");
    	 }
    	 else {
    		 printf("----------------------------------------------------------------------\n");
    		 printf("编号：%d\n", pTemp->id);
    		 printf("姓名：%s\n", pTemp->name);
    		 printf("年龄：%s\n", pTemp->age);
    		 printf("性别：%s\n", pTemp->sex);
    		 printf("手机号：%s\n", pTemp->phone);
    		 printf("住址：%s\n", pTemp->address);
    		 printf("----------------------------------------------------------------------\n");
    	 }
     }

### 3）查询模块 ###

查询模块的设计思路，分“先找址，再输出”两步走。

在此同样为实现模块化，提升编程效率，设计了 Node\* SelectNode1(char xm\[20\])、Node\* SelectNode2(int id)、 Node\* SelectNode3(char phone\[20\])三个指针函数，这三个寻址函数大同小异，因查询的数据不同而互相独立。

由void Select()函数分流给三个寻址函数，再交给void print(Node \* pTemp)函数输出。

//查询指定数据
    void Select()
    {
    	printf("1.按姓名查找\n");
    	printf("2.按编号查询\n");
    	printf("3.按手机号查找\n");
    	int index;
    	int b = 0;
    	scanf("%d", &index);
    	Node* pTemp = phead;
    	switch (index) {
    		//姓名查询
    	case 1:
    	{
    		char name[20];
    		printf("姓名：");
    		scanf("%s", name);
    		pTemp = SelectNode1(name);
    		print(pTemp);	
    	}break;
    	//编号查询
    	case 2:
    	{
    		int id = 0;
    		printf("编号：");
    		scanf("%d", &id);
    		pTemp = SelectNode2(id);
    		print(pTemp);
    	}break;
    	//手机号查询
    	case 3:
    	{
    		char phone[20];
    		printf("手机号：");
    		scanf("%s", phone);
    		pTemp = SelectNode3(phone);
    		print(pTemp);
    	}break;
    	}
    	system("pause");
    	system("cls");
    }
    
    //查询指定节点（name）
    Node* SelectNode1(char xm[20])
    {
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		if (strcmp(xm,pTemp->name)==0)
    		{
    			return pTemp;
    		}
    		pTemp = pTemp->pNext;
    	}
    	//没找到
    	return NULL;
    }
    
    //查询指定节点（id）
    Node* SelectNode2(int id)
    {
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		if ((pTemp->id)==id)
    		{
    			return pTemp;
    		}
    		pTemp = pTemp->pNext;
    	}
    	//没找到
    	return NULL;
    }
    
    //查询指定节点（phone）
    Node* SelectNode3(char phone[20])
    {
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		if (strcmp(phone, pTemp->phone) == 0)
    		{
    			return pTemp;
    		}
    		pTemp = pTemp->pNext;
    	}
    	//没找到
    	return NULL;
    }

### 4）定向删除模块 ###

定向删除模块并不难，先通过寻址函数找到需要删除的节点地址。为提升程序运行效率，如果通讯录只有一个联系人就直接初始化结束。当有两个以上的联系人时，通过对前后联系人首位地址修改，跳过被删除的节点（最后释放其所占内存）。

//定向删除
    void DeleteListRand()
    {
    	
    	if (phead == NULL)
    	{
    		printf("链表为空！\n");
    		system("pause");
    		system("cls");
    		return;
    	}
    	printf("1.按姓名查找\n");
    	printf("2.按编号查询\n");
    	printf("3.按手机号查找\n");
    	int index, yn;
    	scanf("%d", &index);
    	Node* pTemp = phead;
    	switch (index) {
    		//姓名删除
    	case 1: {
    		char name[20];
    		printf("请输入删除的联系人姓名\n");
    		scanf("%s", name);
    		pTemp = SelectNode1(name);
    		print(pTemp);
    	}break;
    		//编号删除
    	case 2: {
    		int id = 0;
    		printf("请输入删除的联系人编号\n");
    		scanf("%d", &id);
    		pTemp = SelectNode2(id);
    		print(pTemp);
    	}break;
    		//手机号删除
    	case 3: {
    		char phone[20];
    		printf("请输入删除的联系人手机号\n");
    		scanf("%s", phone);
    		pTemp = SelectNode3(phone);
    		print(pTemp);
    	}break;
    	}
    	printf("确定删除以上联系人吗？（输入 1 确认删除，输入 0 退出该模块） ： ");
    	scanf("%d", &yn);
    	if (yn == 0) {
    		system("cls");
    	}
    	//开始删除
    	else {
    		//只有一个节点（直接清空）
    		if (phead == pend)
    		{
    			free(phead);
    			phead = NULL;
    			pend = NULL;
    			printf("操作成功\n");
    			n--;
    			system("pause");
    			system("cls");
    			return;
    		}
    		//有两个(及以上)节点
    		else if (phead->pNext == pend)
    		{
    			if (phead == pTemp)
    			{
    				DeleteListHead();
    			}
    			else
    			{
    				DeleteListTail();
    			}
    		}
    		else
    		{
    			if (phead == pTemp)
    			{
    				DeleteListHead();
    			}
    			else if (pend == pTemp)
    			{
    				DeleteListTail();
    			}
    			else
    			{
    				//找到删除节点的前一个节点
    				Node* pT = phead;
    				while (pT->pNext != pTemp)
    				{
    					pT = pT->pNext;
    				}
    				//成功找到后
    				pT->pNext = pTemp->pNext;
    				free(pTemp);
    			}
    
    		}
    		printf("操作成功\n");
    		n--;
    		system("pause");
    		system("cls");
    	}
    }
    
    //头删除
    void DeleteListHead()
    {
    	if (phead == NULL)
    	{
    		printf("链表为空！\n");
    		return;
    	}
    		Node* pTemp = phead;
    		phead = phead->pNext;
    		free(pTemp);
    }
    
    //尾删除
    void DeleteListTail()
    {
    	if (NULL == phead)
    	{
    		printf("链表为空！\n");
    		return;
    	}
    	//链表有一个节点
    	if (phead == pend)
    	{
    		free(phead);
    		phead = NULL;
    		pend = NULL;
    	}
    	else
    	{
    		//找到最后一个节点的前一个节点
    		Node* pTemp = phead;
    		while (pTemp->pNext != pend)
    		{
    			pTemp = pTemp->pNext;
    		}
    		free(pend);
    		pend = pTemp;
    		pend->pNext = NULL;
    	}
    }

### 5）修改模块 ###

修改模块并不难，不过就是在寻址函数的基础上添加修改节点数据的步骤。通过新数据覆盖旧数据的方式，实现通讯录联系人的信息修改。

//修改联系人信息
    void change() {
    	int yn, choose;
    	printf("1.按编号查找\n");
    	printf("2.按姓名查找\n");
    	printf("3.按手机号查找\n");
    	int index;
    	int b = 0;
    	scanf("%d", &index);
    	Node* pTemp = phead;
    	switch (index) {
    	case 1:
    	{
    		int id = 0;
    		printf("编号：");
    		scanf("%d", &id);
    		pTemp = SelectNode2(id);
    	}break;
    	case 2:
    	{
    		char name[20];
    		printf("姓名：");
    		scanf("%s", name);
    		pTemp = SelectNode1(name);
    	}break;
    	case 3:
    	{
    
    		char phone[20];
    		printf("手机号：");
    		scanf("%s", phone);
    		pTemp = SelectNode3(phone);
    	}break;
    	default:return;
    	}
    	print(pTemp);
    	printf("确定修改以上联系人吗？\n（输入 1 进入修改，输入 0 退出该模块） ： ");
    	scanf("%d", &yn);
    	if (yn == 1)
    	{
    		printf("1.姓名    2.年龄    3.性别    4.手机号    5.住址\n请输入序号：");
    		scanf("%d", &choose);
    		switch (choose)
    		{
    		case 1: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->name);
    			printf("修改成功\n");
    		}break;
    		case 2: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->age);
    			printf("修改成功\n");
    		}break;
    		case 3: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->sex);
    			printf("修改成功\n");
    		}break;
    		case 4: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->phone);
    			printf("修改成功\n");
    		}break;
    		case 5: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->address);
    			printf("修改成功\n");
    		}break;
    		}
    		system("pause");
    		system("cls");
    	}
    	system("cls");
    }

### 6）排序模块 ###

在排序模块中，为避免频繁修改链表结构，选择将节点放入相同结构的数组里面，通过改变不同节点的数组下标，调用数组数据等方式实现排序。

//条件排序
    void SortList()
    {
    	int choose;
    	printf("1.按年龄排序\n");
    	printf("2.按编号排序\n");
    	printf("3.按姓名排序\n");
    	printf("4.按手机号排序\n");
    	scanf("%d", &choose);
    	Node* pTemp = phead;
    	Node p[99] = { 0 };
    	//先把储存的节点头地址都放在数组中等待排序
    	for (int i = 0; i < n&&pTemp!=NULL; i++)
    	{
    		p[i] = *pTemp;
    		pTemp = pTemp->pNext;
    	}
    	switch (choose)
    	{
    	  //按年龄排序
    	  case 1:
    	  {
    		  //选择排序法
    		  for (int i = 0; i < n ; i++)
    		  {
    			  for (int j = 1; i+j< n; j++)
    			  {
    				  if (strcmp(p[i].age , p[ i+j ].age) > 0)
    				  {
    					  Node pt = p[i];
    					  p[i] = p[i + j];
    					  p[i + j] = pt;
    				  }
    			  }
    		  }
    		  break;
    	  }
    	  //按编号排序
    	   case 2:
    	   { 
    		   for (int i = 0; i < n; i++)
    		   {
    			   for (int j = 1; i + j < n; j++)
    			   {
    				   if (p[i].id == p[i + j].id)
    				   {
    					   Node pt = p[i];
    					   p[i] = p[i + j];
    					   p[i + j] = pt;
    				   }
    			   }
    		   }
    		   break;
    	   }
    	   //按姓名排序
    	   case 3:
    	   {
    		   //选择排序法
    		   for (int i = 0; i < n; i++)
    		   { 
    			   for (int j = 1; i + j < n; j++)
    			   {
    				   if (strcmp(p[i].name , p[i + j].name) > 0)
    				   {
    					   Node pt = p[i];
    					   p[i] = p[i + j];
    					   p[i + j] = pt;
    				   }
    			   }
    		   }
    		   break;
    	   }
    	   //按手机号排序
    	   case 4:
    	   {
    		   //选择排序法
    		   for (int i = 0; i < n; i++)
    		   {
    			   for (int j = 1; i + j < n; j++)
    			   {
    				   if (strcmp(p[i].phone, p[i + j].phone) > 0)
    				   {
    					   Node pt = p[i];
    					   p[i] = p[i + j];
    					   p[i + j] = pt;
    				   }
    			   }
    		   }
    		   break;
    	   }
    	}
    	system("cls");
    	printf("排序完成！\n");
    	printf("排序后结果为:\n");
    	for (int i = 0; i < n; i++)
    	{
    		printf("编号：%d\n", p[i].id);
    		printf("姓名：%s\n", p[i].name);
    		printf("年龄：%s\n", p[i].age);
    		printf("性别：%s\n", p[i].sex);
    		printf("手机号：%s\n", p[i].phone);
    		printf("住址：%s\n", p[i].address);
    		printf("\n");
    	}
    	system("pause");
    	system("cls");
    }

### 7）清空模块 ###

先把每个节点所占内存逐一释放，然后将链表的首尾指针地址归零。这种方式最为合理有效。

//链表清空
    void FreeList()
    {
    	int yn = 1;
    	printf("确定清空联系人吗？（输入 1 确认清空，输入 0 退出该模块） ： ");
    	scanf("%d", &yn);
    	if (yn == 0) {
    		system("cls");
    	}
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		Node* pt = pTemp;
    		pTemp = pTemp->pNext;
    		free(pt);
    	}
    	phead = NULL;
    	pend = NULL;
    	printf("已全部清除\n");
    	n = 0;
    	idnumber = 0;
    	system("pause");
    	system("cls");
    }

--------------------

# 四、总结及分析 #

**自我总结：**

C语言作为一门基础语言，我觉得最精华的部分就是C语言的指针、链表和结构部分。前面所学的知识，只有在指针结构链表的基础上，才能发挥更大的作用。

通讯录管理系统是我设计的第1个系统，面对现实当中通讯录管理的实际需求，我总结分析并设计了不同模块来满足需求。在模块的设计和调试当中，我感受到对链表、指针等方面有了更多的领悟，我会在之后巩固链表结构指针方面的知识，坚持勤学勤练。在本次设计当中有许多我想要实现的复杂功能没能成功，系统在体验方面仍有不足。我会继续努力探索，掌握技巧实现更多更便利的功能。

以下是个人对链表、指针的领悟：

#define LEN sizeof(Node)
    Node* pTemp = (Node*)malloc(LEN);

**LEN**是我自己定义的数据结构所需要的内存量，malloc为我**产生一个空白指针a**（著名a无意义仅用描述）来**保存**内存长度为LEN的空白变量x（著名x无意义仅用描述）的**头地址**，接着（Node\*）给空白指针a赋予Node类型（等同于给x进行规划）然后指针a变成半空白指针（有类型但无名）。最后Node\*pTemp=半空白指针a（相当于给a命名为pTemp）。

需要注意的是，不能死死扣在指针就是“指向”。因为指向这个概念非常抽象，不利于以后学习的深入。指针变量也是变量，只不过别的变量存储的是字符、数字等，而指针变量存储的是其他变量的地址。

当出现这样的赋值语言“**指针变量A = 指针变量B****”****  **这句话的意思是用指针变量A来使唤指针变量B，某种意义上A、B二者是同一个东西了**。**

--------------------

# 程序代码 #

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<conio.h>
    int n;//记录人数
    int idnumber=0;//赋予编号（唯一性，不可修改性）
    typedef struct Node
    {
    	int id;//编号
    	char name[20];//姓名
    	char age[20];//年龄
    	char sex[20];//性别
    	char phone[20];//手机号
    	char address[20];//住址
    	struct Node* pNext;
    }Node;
    #define LEN sizeof(Node)
     Node* phead = NULL;
     Node* pend = NULL;
     
     //打印模块
     void print(Node* pTemp);
     //新建联系人
     void AddNodeList();
     //显示全部数据
     void ScanList();
     //查询指定节点（姓名）
     Node* SelectNode1(char xm[20]);
     //查询指定节点（id）
     Node* SelectNode2(int id);
     //查询指定节点（phone）
     Node* SelectNode3(char phone[20]);
     //查询指定数据
     void Select();
     //定向删除
     void DeleteListRand();
     //头删除
     void DeleteListHead();
     //尾删除
     void DeleteListTail();
     //条件排序
     void SortList();
     //链表清空
     void FreeList();
     //菜单打印
     void showmenu();
     //修改联系人信息
     void change();
     
     
     //主函数
     int main()
     {
    	 phead;
    	 int choose;
    	 while (1)
    	 {
    		 showmenu();
    		 printf("请输入选择的功能序号: ");
    		 scanf("%d", &choose);
    		 switch (choose)
    		 {
    		 case 1:
    			 n++;
    			 idnumber++;
    			 AddNodeList();
    			 break;
    		 case 2:
    			 ScanList();
    			 break;
    		 case 3:
    			 Select();
    			 break;
    		 case 4:
    			 DeleteListRand();
    			 break;
    		 case 5:
    			 change();
    			 break;
    		 case 6:
    			 SortList();
    			 break;
    		 case 7:
    			 FreeList();
    			 break;
    		 default:
    			 break;
    		 }
    	 }
    	 system("pause");
    	 return 0;
     }
     
     //打印模块
     void print(Node* pTemp) {
    	 if (pTemp == NULL) {
    		 printf("\n--------------------您要查找的联系人不存在!--------------------------------\n");
    	 }
    	 else {
    		 printf("----------------------------------------------------------------------\n");
    		 printf("编号：%d\n", pTemp->id);
    		 printf("姓名：%s\n", pTemp->name);
    		 printf("年龄：%s\n", pTemp->age);
    		 printf("性别：%s\n", pTemp->sex);
    		 printf("手机号：%s\n", pTemp->phone);
    		 printf("住址：%s\n", pTemp->address);
    		 printf("----------------------------------------------------------------------\n");
    	 }
     }
    
     //添加联系人
    void AddNodeList()
    {
    	//创建一个节点
    	 Node* pTemp = (Node*)malloc(LEN);
    	//节点数据赋值
    	 printf("编号为%d\n", idnumber);
    	pTemp->id = idnumber;
    	printf("请输入姓名：");
    	scanf("%s", pTemp->name);
    	printf("\n");
    	printf("请输入年龄：");
    	scanf("%s", pTemp->age);
    	printf("\n");
    	printf("请输入性别：");
    	scanf("%s", pTemp->sex);
    	printf("\n");
    	printf("请输入手机号：");
    	scanf("%s", pTemp->phone);
    	printf("\n");
    	printf("请输入住址：");
    	scanf("%s", pTemp->address);
    	printf("\n");
    	pTemp->pNext = NULL;
    	//链接
    	if (NULL == phead)
    	{
    		phead = pTemp;
    		pend = pTemp;
    	}
    	else
    	{
    		pend->pNext = pTemp;
    		pend = pTemp;
    	}
    	system("pause");
    	system("cls");
    }
    
    //显示全部数据
    void ScanList()
    {
    	if (phead == NULL) {
    		printf("无任何联系人。\n");
    	} return;
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		print(pTemp);
    		pTemp = pTemp->pNext;
    	}
    	system("pause");
    	system("cls");
    }
    
    //查询指定节点（姓名）
    Node* SelectNode1(char xm[20])
    {
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		if (strcmp(xm,pTemp->name)==0)
    		{
    			return pTemp;
    		}
    		pTemp = pTemp->pNext;
    	}
    	//没找到
    	return NULL;
    }
    
    //查询指定节点（id）
    Node* SelectNode2(int id)
    {
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		if ((pTemp->id)==id)
    		{
    			return pTemp;
    		}
    		pTemp = pTemp->pNext;
    	}
    	//没找到
    	return NULL;
    }
    
    //查询指定节点（phone）
    Node* SelectNode3(char phone[20])
    {
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		if (strcmp(phone, pTemp->phone) == 0)
    		{
    			return pTemp;
    		}
    		pTemp = pTemp->pNext;
    	}
    	//没找到
    	return NULL;
    }
    
    //查询指定数据
    void Select()
    {
    	printf("1.按姓名查找\n");
    	printf("2.按编号查询\n");
    	printf("3.按手机号查找\n");
    	int index;
    	int b = 0;
    	scanf("%d", &index);
    	Node* pTemp = phead;
    	switch (index) {
    		//姓名查询
    	case 1:
    	{
    		char name[20];
    		printf("姓名：");
    		scanf("%s", name);
    		pTemp = SelectNode1(name);
    		print(pTemp);	
    	}break;
    	//编号查询
    	case 2:
    	{
    		int id = 0;
    		printf("编号：");
    		scanf("%d", &id);
    		pTemp = SelectNode2(id);
    		print(pTemp);
    	}break;
    	//手机号查询
    	case 3:
    	{
    		char phone[20];
    		printf("手机号：");
    		scanf("%s", phone);
    		pTemp = SelectNode3(phone);
    		print(pTemp);
    	}break;
    	}
    	system("pause");
    	system("cls");
    }
    
    //定向删除
    void DeleteListRand()
    {
    	
    	if (phead == NULL)
    	{
    		printf("链表为空！\n");
    		system("pause");
    		system("cls");
    		return;
    	}
    	printf("1.按姓名查找\n");
    	printf("2.按编号查询\n");
    	printf("3.按手机号查找\n");
    	int index, yn;
    	scanf("%d", &index);
    	Node* pTemp = phead;
    	switch (index) {
    		//姓名删除
    	case 1: {
    		char name[20];
    		printf("请输入删除的联系人姓名\n");
    		scanf("%s", name);
    		pTemp = SelectNode1(name);
    		print(pTemp);
    	}break;
    		//编号删除
    	case 2: {
    		int id = 0;
    		printf("请输入删除的联系人编号\n");
    		scanf("%d", &id);
    		pTemp = SelectNode2(id);
    		print(pTemp);
    	}break;
    		//手机号删除
    	case 3: {
    		char phone[20];
    		printf("请输入删除的联系人手机号\n");
    		scanf("%s", phone);
    		pTemp = SelectNode3(phone);
    		print(pTemp);
    	}break;
    	}
    	printf("确定删除以上联系人吗？（输入 1 确认删除，输入 0 退出该模块） ： ");
    	scanf("%d", &yn);
    	if (yn == 0) {
    		system("cls");
    	}
    	//开始删除
    	else {
    		//只有一个节点（直接清空）
    		if (phead == pend)
    		{
    			free(phead);
    			phead = NULL;
    			pend = NULL;
    			printf("操作成功\n");
    			n--;
    			system("pause");
    			system("cls");
    			return;
    		}
    		//有两个(及以上)节点
    		else if (phead->pNext == pend)
    		{
    			if (phead == pTemp)
    			{
    				DeleteListHead();
    			}
    			else
    			{
    				DeleteListTail();
    			}
    		}
    		else
    		{
    			if (phead == pTemp)
    			{
    				DeleteListHead();
    			}
    			else if (pend == pTemp)
    			{
    				DeleteListTail();
    			}
    			else
    			{
    				//找到删除节点的前一个节点
    				Node* pT = phead;
    				while (pT->pNext != pTemp)
    				{
    					pT = pT->pNext;
    				}
    				//成功找到后
    				pT->pNext = pTemp->pNext;
    				free(pTemp);
    			}
    
    		}
    		printf("操作成功\n");
    		n--;
    		system("pause");
    		system("cls");
    	}
    }
    
    //头删除
    void DeleteListHead()
    {
    	if (phead == NULL)
    	{
    		printf("链表为空！\n");
    		return;
    	}
    		Node* pTemp = phead;
    		phead = phead->pNext;
    		free(pTemp);
    }
    
    //尾删除
    void DeleteListTail()
    {
    	if (NULL == phead)
    	{
    		printf("链表为空！\n");
    		return;
    	}
    	//链表有一个节点
    	if (phead == pend)
    	{
    		free(phead);
    		phead = NULL;
    		pend = NULL;
    	}
    	else
    	{
    		//找到最后一个节点的前一个节点
    		Node* pTemp = phead;
    		while (pTemp->pNext != pend)
    		{
    			pTemp = pTemp->pNext;
    		}
    		free(pend);
    		pend = pTemp;
    		pend->pNext = NULL;
    	}
    }
    
    //条件排序
    void SortList()
    {
    	int choose;
    	printf("1.按年龄排序\n");
    	printf("2.按编号排序\n");
    	printf("3.按姓名排序\n");
    	printf("4.按手机号排序\n");
    	scanf("%d", &choose);
    	Node* pTemp = phead;
    	Node p[99] = { 0 };
    	//先把储存的节点头地址都放在数组中等待排序
    	for (int i = 0; i < n&&pTemp!=NULL; i++)
    	{
    		p[i] = *pTemp;
    		pTemp = pTemp->pNext;
    	}
    	switch (choose)
    	{
    	  //按年龄排序
    	  case 1:
    	  {
    		  //选择排序法
    		  for (int i = 0; i < n ; i++)
    		  {
    			  for (int j = 1; i+j< n; j++)
    			  {
    				  if (strcmp(p[i].age , p[ i+j ].age) > 0)
    				  {
    					  Node pt = p[i];
    					  p[i] = p[i + j];
    					  p[i + j] = pt;
    				  }
    			  }
    		  }
    		  break;
    	  }
    	  //按编号排序
    	   case 2:
    	   { 
    		   for (int i = 0; i < n; i++)
    		   {
    			   for (int j = 1; i + j < n; j++)
    			   {
    				   if (p[i].id == p[i + j].id)
    				   {
    					   Node pt = p[i];
    					   p[i] = p[i + j];
    					   p[i + j] = pt;
    				   }
    			   }
    		   }
    		   break;
    	   }
    	   //按姓名排序
    	   case 3:
    	   {
    		   //选择排序法
    		   for (int i = 0; i < n; i++)
    		   { 
    			   for (int j = 1; i + j < n; j++)
    			   {
    				   if (strcmp(p[i].name , p[i + j].name) > 0)
    				   {
    					   Node pt = p[i];
    					   p[i] = p[i + j];
    					   p[i + j] = pt;
    				   }
    			   }
    		   }
    		   break;
    	   }
    	   //按手机号排序
    	   case 4:
    	   {
    		   //选择排序法
    		   for (int i = 0; i < n; i++)
    		   {
    			   for (int j = 1; i + j < n; j++)
    			   {
    				   if (strcmp(p[i].phone, p[i + j].phone) > 0)
    				   {
    					   Node pt = p[i];
    					   p[i] = p[i + j];
    					   p[i + j] = pt;
    				   }
    			   }
    		   }
    		   break;
    	   }
    	}
    	system("cls");
    	printf("排序完成！\n");
    	printf("排序后结果为:\n");
    	for (int i = 0; i < n; i++)
    	{
    		printf("编号：%d\n", p[i].id);
    		printf("姓名：%s\n", p[i].name);
    		printf("年龄：%s\n", p[i].age);
    		printf("性别：%s\n", p[i].sex);
    		printf("手机号：%s\n", p[i].phone);
    		printf("住址：%s\n", p[i].address);
    		printf("\n");
    	}
    	system("pause");
    	system("cls");
    }
    
    //链表清空
    void FreeList()
    {
    	int yn = 1;
    	printf("确定清空联系人吗？（输入 1 确认清空，输入 0 退出该模块） ： ");
    	scanf("%d", &yn);
    	if (yn == 0) {
    		system("cls");
    	}
    	Node* pTemp = phead;
    	while (pTemp != NULL)
    	{
    		Node* pt = pTemp;
    		pTemp = pTemp->pNext;
    		free(pt);
    	}
    	phead = NULL;
    	pend = NULL;
    	printf("已全部清除\n");
    	n = 0;
    	idnumber = 0;
    	system("pause");
    	system("cls");
    }
    
    //打印菜单
    void showmenu()
    {
    	printf("--------------------《通讯录管理系统菜单》--------------------\n");
    	printf("-------------------1.新建联系人-------------------------------\n");
    	printf("-------------------2.显示全部信息-----------------------------\n");
    	printf("-------------------3.查询指定联系人---------------------------\n");
    	printf("-------------------4.删除指定联系人---------------------------\n");
    	printf("-------------------5.修改指定联系人---------------------------\n");
    	printf("-------------------6.排序全部联系人---------------------------\n");
    	printf("-------------------7.清空全部联系人---------------------------\n");
    }
    
    //修改联系人信息
    void change() {
    	int yn, choose;
    	printf("1.按编号查找\n");
    	printf("2.按姓名查找\n");
    	printf("3.按手机号查找\n");
    	int index;
    	int b = 0;
    	scanf("%d", &index);
    	Node* pTemp = phead;
    	switch (index) {
    	case 1:
    	{
    		int id = 0;
    		printf("编号：");
    		scanf("%d", &id);
    		pTemp = SelectNode2(id);
    	}break;
    	case 2:
    	{
    		char name[20];
    		printf("姓名：");
    		scanf("%s", name);
    		pTemp = SelectNode1(name);
    	}break;
    	case 3:
    	{
    
    		char phone[20];
    		printf("手机号：");
    		scanf("%s", phone);
    		pTemp = SelectNode3(phone);
    	}break;
    	default:return;
    	}
    	print(pTemp);
    	printf("确定修改以上联系人吗？\n（输入 1 进入修改，输入 0 退出该模块） ： ");
    	scanf("%d", &yn);
    	if (yn == 1)
    	{
    		printf("1.姓名    2.年龄    3.性别    4.手机号    5.住址\n请输入序号：");
    		scanf("%d", &choose);
    		switch (choose)
    		{
    		case 1: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->name);
    			printf("修改成功\n");
    		}break;
    		case 2: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->age);
    			printf("修改成功\n");
    		}break;
    		case 3: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->sex);
    			printf("修改成功\n");
    		}break;
    		case 4: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->phone);
    			printf("修改成功\n");
    		}break;
    		case 5: {
    			printf("请输入新值：");
    			scanf("%s", pTemp->address);
    			printf("修改成功\n");
    		}break;
    		}
    		system("pause");
    		system("cls");
    	}
    	system("cls");
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxMzIzNTIw_size_16_color_FFFFFF_t_70]: /images/20221119/3f63f5ca554642118621ecb9baba3c99.png