list.h
#pragma once //预防头文件重复引用
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include <windows.h>
#include<assert.h>
#define MAX_N 30 //姓名最大长度
#define MAX_T 15 //电话号码最大长度
#define MAX_A 100 //地址最大长度
//用户信息结构体
typedef struct InfoNode
{
char _name[MAX_N]; //姓名
char _telephone[MAX_T]; //电话号码
char _address[MAX_A]; //地址
}InfoNode;
//输入时以循环双链表存储
typedef struct InfoNode_List
{
InfoNode* _ListInfo; //结构体指针来存放用户信息
struct InfoNode_List* _next; //指向下一个节点
struct InfoNode_List* _pre; //指向上一个节点
}InfoNode_List;
//初始化链表
void InitList(InfoNode_List* pl);
//输入用户信息节点
void ScanfNode(InfoNode* pnode);
//增加链表节点
void AddList(InfoNode_List* pl);
//修改用户信息
void ChangeNode(InfoNode* pnode);
//删除节点
void DeleteListNode(InfoNode_List* pl);
//姓名查找
InfoNode_List* FindName(InfoNode_List* phead, char* name);
//电话号码查找
InfoNode_List* FindTelephone(InfoNode_List* phead, char* telephone);
//打印信息
void ShowInfo(InfoNode_List* phead);
//打印一个用户的信息
void ShowOnce(InfoNode* pi);
//按字符ASCLL比较两个用户信息的大小
int CompareInfo(InfoNode* pi1, InfoNode* pi2);
//排序 --> 插入排序法
void InsertSort(InfoNode_List* phead);
//当前信息写入文件
void WriteFileInfo(InfoNode_List* phead);
//读取把文件信息插入链表 (头插法)
void ReadFileInfo(InfoNode_List* phead);
//模拟加载页面
void my_loading(const int time);
//0.5秒睡眠加清屏
void SleepCls();
//模拟进度条
void ProgressBar();
list.c
#include "list.h"
//睡眠加清屏
void SleepCls()
{
Sleep(500);//程序在这里暂停0.5秒
system("cls");//清屏操作
}
//模拟进度条
void ProgressBar()
{
int i = 0;
char arr[51] = { 0 }; //存放进度的"#"
char* brr = "|/-\\"; //模拟转圈圈
printf("\n");
for (i = 0; i < 50; i++)
{
arr[i] = '#';
printf("[%-50s][%d%%][%c]\r", arr, (i + 1) * 2, brr[i % 4]);
Sleep(50);
}
printf("\n"); //退格后的光标向下一行移动
}
//初始化链表
void InitList(InfoNode_List* phead)
{
assert(phead);
phead->_next = phead; //头结点的下一个节点指向自己
phead->_pre = phead; //头结点的上一个节点指向自己
}
//节点输入用户信息
void ScanfNode(InfoNode* pnode)
{
char name[MAX_N] = { '\0' }, telephone[MAX_T] = { '\0' }, address[MAX_A] = { '\0' };
printf("_______________________________________\n");
printf("|\n");
printf("|请输入用户姓名-->");
scanf("%s", name);
strcpy(pnode->_name, name);
printf("|请输入用户电话号码-->");
scanf("%s",telephone);
strcpy(pnode->_telephone, telephone);
printf("|请输入用户地址-->");
scanf("%s",address);
strcpy(pnode->_address, address);
printf("|______________________________________\n");
}
//修改用户信息
void ChangeNode(InfoNode* pnode)
{
char choose_C;
char name[MAX_N] = { '\0' }, telephone[MAX_T] = { '\0' }, address[MAX_A] = { '\0' };
printf("_______________________________________\n");
printf("|\n");
printf("|请输入修改后用户姓名-->");
scanf("%s", name);
strcpy(pnode->_name, name);
printf("|请输入修改后用户电话号码-->");
scanf("%s", telephone);
strcpy(pnode->_telephone, telephone);
printf("|是否修改用户的地址(Y或者y)-->");
getchar(); //吸收电话号码输入后的回车字符
scanf("%c", &choose_C);
if (choose_C == 'y' || choose_C == 'Y')
{
printf("|请输入用户地址-->");
scanf("%s", address);
strcpy(pnode->_address, address);
}
else
{
printf("|用户地址 -->%s\n", pnode->_address);
}
printf("|______________________________________\n");
}
//增加用户信息
void AddList(InfoNode_List* phead) //采用头插法
{
assert(phead); //防止传入野指针
InfoNode_List* node;
node = (InfoNode_List*)malloc(sizeof(InfoNode_List));
node->_ListInfo = (InfoNode*)malloc(sizeof(InfoNode)); //为用户信息结构体开辟空间
ScanfNode(node->_ListInfo); //输入用户信息
//头插法进行节点的插入
node->_next = phead->_next;
phead->_next->_pre = node;
node->_pre = phead;
phead->_next = node;
printf("----------------------------------\n");
printf("%s的信息增加完毕\n\n", node->_ListInfo->_name);
}
//删除节点
void DeleteListNode(InfoNode_List* phead)
{
assert(phead);
InfoNode_List* pre = (InfoNode_List*)malloc(sizeof(InfoNode_List));
char sure='\0';
int option=0;
//打印内部菜单
printf("-----------------------------------------\n");
printf("|\t按用户姓名删除(系统默认)-->1\t|\n");
printf("-----------------------------------------\n");
printf("|\t按用户电话号码查找并删除-->0\t|\n");
printf("-----------------------------------------\n");
printf("您的选择-->");
scanf("%d", &option);
if (option != 0) //默认按照姓名查询删除
{
option = 1;
}
getchar(); //吸收scanf函数输入停止时的回车字符
switch (option)
{
case 1:
{
char name[MAX_N] = { '\0' };
printf("请输入想要删除联系人的姓名-->");
gets(name);
pre = FindName(phead, name); //返回要删除节点
break;
}
case 0:
{
char telephone[MAX_T] = { '\0' };
printf("请输入想要删除用户的电话号码-->");
gets(telephone);
pre = FindTelephone(phead, telephone); //返回要删除节点
break;
}
}
if (pre) //如果找到该节点,最后确认一次是否删除
{
printf("确认删除?y/Y -->");
scanf("%c", &sure);
if (sure == 'y' || sure == 'Y') //确认删除进行链表删除操作
{
InfoNode_List* cur = pre;
cur->_pre->_next = cur->_next;
cur->_next->_pre = cur->_pre;
free(cur); //释放掉要删除的节点空间
printf("删除成功\n");
}
else
{
printf("取消删除,返回主页面\n"); //不想删除则返回主页面
}
}
}
//姓名查找(删除函数中调用)
InfoNode_List* FindName(InfoNode_List* phead, char* name)
{
assert(phead && name); //防止传入野指针
InfoNode_List* node = phead->_next; //保留头结点位置
//寻找该用户
//循环结束的条件 链表指针node指向头结点 或 node节点为要删除的节点
while (node!=phead && strcmp(node->_ListInfo->_name, name) != 0)
{
node = node->_next; //移动指针
}
if (node!=phead)
{
//找到后进行打印
printf("该用户已经找到\n");
ShowOnce(node->_ListInfo);
return node; //返回要删除节点
}
else
{
printf("没有找到该用户,将返回主页面\n");
return NULL; //返回为NULL
}
}
//打印链表中的用户信息
void ShowInfo(InfoNode_List* phead)
{
assert(phead);
InfoNode_List* node = phead->_next;
if (node==phead) //防止链表中没有用户信息
{
printf("没有用户信息可以打印\n");
return;
}
printf("_________________________________________________________\n");
printf("\t姓名\t 电话号码\t 地址\n");
printf("_________________________________________________________\n");
while (node!=phead)
{
printf("%12s\t%11s\t%s\n", node->_ListInfo->_name, \
node->_ListInfo->_telephone, \
node->_ListInfo->_address);
printf("---------------------------------------------------------\n");
node = node->_next;
}
}
//打印一个节点的信息
void ShowOnce(InfoNode* pi)
{
assert(pi);
printf(" _________________________________________________\n");
printf("|\n");
printf("|姓名: %s\n", pi->_name);
printf("|电话号码:%s\n", pi->_telephone);
printf("|地址: %s\n", pi->_address);
printf("|_________________________________________________\n");
}
//电话号码查找(删除函数中调用)
InfoNode_List* FindTelephone(InfoNode_List* phead, char* telephone)
{
assert(phead && telephone); //防止传入野指针
InfoNode_List* node = phead->_next; //保留头结点位置
//寻找该用户
//循环结束的条件 链表指针node指向phead 或 node为要删除的节点
while (node!=phead && strcmp(node->_ListInfo->_telephone, telephone) != 0)
{
node = node->_next; //移动节点
}
if (node!=phead) //如果找到,对要删除节点进行打印
{
printf("该用户已经找到\n");
ShowOnce(node->_ListInfo);
return node; //函数返回要删除节点
}
else
{
printf("没有找到该用户,将返回主页面\n");
return NULL; //没有找到则返回NULL
}
}
//按字符ASCLL比较两个用户信息的大小
int CompareInfo(InfoNode* pi1, InfoNode* pi2)
{
assert(pi1 && pi2);
int ans=0; //记录比较后的结果
/*ans = strcmp(pi1->_name, pi2->_name); //先按照姓名比较
if (ans == 0) //结果为0,表示名字相等 再比较电话号码
{
//电话号码不可能相等,返回比较后的结果
ans = strcmp(pi1->_telephone, pi2->_telephone);
}
return ans;*/
return (ans = strcmp(pi1->_name, pi2->_name)) != 0 ? \
ans : strcmp(pi1->_telephone, pi2->_telephone);
}
//排序 --> 循环双链表的插入排序法
void InsertSort(InfoNode_List* phead)
{
assert(phead);
InfoNode_List* cur = phead->_next; //cur 指针记录当前被比较的节点
InfoNode_List* node = cur->_next; //node 指针记录需要比较的节点
InfoNode_List* nodenext; //nodenext 指针记录下一个需要比较的节点
while (node!=phead) //循环退出的条件 node节点不是头结点
{
cur = phead->_next; //每次比较都从头结点的下一个节点开始
//找到第一个比node节点信息大的节点,这个节点记录为cur
while (cur != node && \
CompareInfo(cur->_ListInfo, node->_ListInfo) <= 0)
{
cur = cur->_next;
}
nodenext = node->_next; //保存需要比较节点的下一个节点
//如果cur==node 表示该节点就是前面节点中最大的,不做处理,跳出循环
if (cur != node)
{
//先连接node节点的前后两个节点
nodenext->_pre = node->_pre;
node->_pre->_next = nodenext;
//再连接node节点和cur节点的前一个节点
cur->_pre->_next = node;
node->_pre = cur->_pre;
//最后把node节点和cur连接,完成在cur节点的前面插入
node->_next = cur;
cur->_pre = node;
}
//把下一个需要比较的节点给node
node = nodenext;
nodenext = node->_next;
}
char choose_s='\0';
my_loading(3);
printf("链表信息的排序已完成\n");
printf("是否显示排序后的链表(y或Y)-->");
scanf("%c", &choose_s);
if (choose_s == 'y' || choose_s == 'Y')
{
SleepCls(); //睡眠加清屏
ShowInfo(phead); //打印信息
}
}
//模拟加载界面
void my_loading(const int time)
{
int i = 0;
for (i = 1; i < time; i++)
{
printf("\t%d......\n",i);
Sleep(500);
}
}
//将链表的信息写入文件
void WriteFileInfo(InfoNode_List* phead)
{
assert(phead);
InfoNode_List* node = phead->_next;
if (node==phead) //防止链表中没有用户信息
{
printf("没有需要储存的用户信息\n");
return;
}
int num = 0; //记录用户数量
FILE* fp; //文件指针
fp = fopen("text.txt", "w"); // 打开写入的文件
//文件指针完成的功能是写,打开的文件是 text.txt
while (node!=phead)
{
fprintf(fp, "-%s\t\t%s\t\t%s\n", node->_ListInfo->_name, \
node->_ListInfo->_telephone,\
node->_ListInfo->_address);
node = node->_next;
num++; //记录载入用户的数量
}
fprintf(fp, "|\t\t共%d个用户信息\t\t|\n",num);
fclose(fp); //关闭文件
my_loading(4); //模拟加载界面
printf("用户信息已保存\n");
}
//读取文件中的信息
void ReadFileInfo(InfoNode_List* phead)
{
assert(phead);
FILE* fp; //建立文件指针
char flag='\0'; //判断文件读取结束的标志
fp = fopen("text.txt", "r"); //打开文件
while ((flag = fgetc(fp)) != '|')
{
//创建一个节点来存储文件中的用户信息
InfoNode_List* node;
node = (InfoNode_List*)malloc(sizeof(InfoNode_List));
//为用户信息结构体开辟空间
node->_ListInfo = (InfoNode*)malloc(sizeof(InfoNode));
fscanf(fp, "%s%s%s", node->_ListInfo->_name, \
node->_ListInfo->_telephone, \
node->_ListInfo->_address);
flag = fgetc(fp); //处理掉当前行末的换行符
//节点插入(尾插法)
//先把node节点和链表的尾连起来
node->_pre = phead->_pre->_next;
phead->_pre->_next = node;
//再把node节点和链表的头连接起来
node->_next = phead;
phead->_pre = node;
}
fclose(fp); //关闭文件
my_loading(4); //模拟加载界面
printf("用户电话号码信息载入完毕\n");
}
hashname.h
#include"list.h"
//用姓名为关键字建立哈希表
//取权值的公式 姓名的首尾字符相加再对50取余
//处理冲突的方法 再散列法
#define DIV (50) //除留余数法的除数
typedef struct HTName
{
InfoNode* _NameInfo; //用户信息
int _key; //建表后的权值
int _ishave; //判断该位置有没有填入用户
}HTName;
typedef struct NameTableH
{
HTName* _NameArr; //动态开辟数组来存放用户信息
int _psize; //当前存放信息的用户数量
int _capacity; //数组当前的容量
}NameTableH;
//初始化哈希表
void InitNameTableH(NameTableH* pn);
//哈希表扩容
void AddCapacity(NameTableH* pn,const int key);
//建立哈希表
void SetNameTableH(NameTableH* pn, InfoNode_List* phead);
//查找用户信息
int FindNameTableH(NameTableH* pn, const char* name);
//修改用户信息
void ChangeNameTableH(NameTableH* pn);
hashname.c
#include "hashname.h"
//初始化哈希表
void InitNameTableH(NameTableH* pn)
{
assert(pn);
pn->_psize = 0; //数组中没有成员
pn->_capacity = DIV; //数组当前的容量为除留余数法的除数
pn->_NameArr = (HTName*)malloc(sizeof(HTName)*pn->_capacity);
//为数组开辟当前容量的空间
int i = 0;
for (i = 0; i < pn->_capacity; i++)
{
//将数组每个位置初始化为0
//0表示该位置没有存放成员信息
pn->_NameArr[i]._ishave = 0;
}
}
//哈希表扩容
void AddCapacity(NameTableH* pn, const int key)
{
assert(pn && key < pn->_capacity);
pn->_capacity *= 2;
pn->_NameArr = (HTName*)realloc(pn->_NameArr, sizeof(HTName)*pn->_capacity);
//realloc函数进行扩容,不会改变数组原来空间内容的信息
//每次扩容的大小为当前容量的2倍
int i = 0;
for (i = pn->_psize;i< pn->_capacity; i++)
{
pn->_NameArr[i]._ishave = 0; //初始化新增加的空间有无用户的情况
}
//为了不改变哈希表查找时候的顺序
//扩容完毕后,将数组中当前权值前面的信息都依次移动到新开辟的地方后面
for (i = 0; i < key; i++)
{
pn->_NameArr[i + pn->_psize]._NameInfo = pn->_NameArr[i]._NameInfo; //用户信息移动
pn->_NameArr[i + pn->_psize]._key = pn->_NameArr[i]._key; //权值移动
pn->_NameArr[i]._ishave = 0; //当前位置置为无值
pn->_NameArr[i + pn->_psize]._ishave = 1; //移动后的位置置为有值
}
}
//建立哈希表
void SetNameTableH(NameTableH* pn, InfoNode_List* phead)
{
assert(pn && phead);
if (phead==phead->_next)
{
printf("没有用户的信息!\n");
return;
}
InfoNode_List* node = phead->_next;
char Fname, Lname; //一个表示姓名的首字符,一个表示尾字符
int len; //表示姓名的长度
int key; //表示计算后的权值
while (node!=phead)
{
Fname = node->_ListInfo->_name[0];
len = strlen(node->_ListInfo->_name);
Lname = node->_ListInfo->_name[len-1];
key = (int)(Fname + Lname) % DIV; //计算权值
if (pn->_psize == pn->_capacity) //判断是否需要扩容
{
AddCapacity(pn,key);
}
if (!pn->_NameArr[key]._ishave)//该位置没有出现冲突
{
//将该节点中用户信息节点 赋值给 哈希表中该位置用户信息节点
pn->_NameArr[key]._NameInfo = node->_ListInfo;
//记录该位置权值
pn->_NameArr[key]._key = key;
//修改该位置为有值
pn->_NameArr[key]._ishave = 1;
}
else //出现冲突,用再散列法解决冲突
{
int i = key+1;
while (pn->_NameArr[i]._ishave)//找到第一个不冲突的节点
{
i = (i + 1) % pn->_capacity;//让该位置在逻辑上动态连接起来
}
//将该节点中用户信息节点 赋值给 哈希表中该位置用户信息节点
pn->_NameArr[i]._NameInfo = node->_ListInfo;
//记录该位置权值
pn->_NameArr[i]._key = key;
//修改该位置为有值
pn->_NameArr[i]._ishave = 1;
}
node = node->_next;
pn->_psize++;
}
ProgressBar(); //模拟进度条
printf("\t姓名哈希表建立完毕\n");
SleepCls(); //0.5秒睡眠+清屏
}
//查找用户信息
int FindNameTableH(NameTableH* pn, const char* name)
{
assert(pn && name);
char Fname, Lname;
Fname = name[0];
int len = strlen(name);
Lname = name[len - 1]; //取首字符和尾字符
int key = (int)(Fname + Lname) % DIV; //计算权值
int i = key;
int count = 0;
//查找时循环跳出的条件
//1.当前位置没有存放用户信息
//2.如果数组可以存放的用户已经满了,并且没有需要查找的人
//即循环走了当前容量的步骤 ---> count==pn->_capacity
//3.权值相同
while ( pn->_NameArr[i]._ishave \
&& (count++)<pn->_capacity \
&& pn->_NameArr[i]._key != key)
{
i = (i + 1) % pn->_capacity;
}
//判断是哪种条件跳出循环
//如果是1 2 ,则表示没有找到,退出函数
if (pn->_capacity == count || !pn->_NameArr[i]._ishave)
{
printf("没有找到该用户\n");
return -1;
}
//3 表示找到,进行打印
ShowOnce(pn->_NameArr[i]._NameInfo);
return i;
}
//修改用户信息
void ChangeNameTableH(NameTableH* pn)
{
assert(pn);
char name[MAX_N] = { '\0' };
printf("请输入需要修改的用户的姓名-->");
scanf("%s", name);
int i = FindNameTableH(pn,name); //调用函数先来查找用户
system("pause"); //程序暂停,按任意键继续
if (i != -1) //表示找到该用户
{
SleepCls();
printf("请重新输入该用户的信息:\n");
ChangeNode(pn->_NameArr[i]._NameInfo);//重新输入该用户的信息,选择性输入地址
}
}
hashtele.h
#include "list.h"
//以用户的电话号码为关键字建立散列表
//取权值的公式 电话号码每个数字字符相加 对50取余
//处理冲突的方法 链地址法
#define MAX_TELEARR 50 //链的最大高度
typedef struct HTTele //链地址法每个节点
{
InfoNode* _TeleInfo; //用户信息
struct HTTele* next; //逻辑上连接下一个同权值的节点
}HTTele;
typedef struct TeleListH
{
HTTele* _TeleArr; //链的头
}TeleListH;
//初始化哈希链
void InitTeleListH(TeleListH* pt);
//建立哈希链
void SetTeleListH(TeleListH* pt, InfoNode_List* phead);
//电话号码查找用户
InfoNode* FindTeleListH(TeleListH* pt, const char* telephone);
//修改用户信息
void ChangeTeleListH(TeleListH* pt);
hashtele.c
#include "list.h"
#include "hashtele.h"
//初始化哈希链
void InitTeleListH(TeleListH* pt)
{
assert(pt);
pt->_TeleArr = (HTTele*)malloc(sizeof(HTTele)*MAX_TELEARR); //开辟存储信息的空间
int i = 0;
for (i = 0; i < MAX_TELEARR; i++)
{
pt->_TeleArr[i].next = NULL; //每一层的链头的next指针初始化为NULL
}
}
//建立哈希链
void SetTeleListH(TeleListH* pt, InfoNode_List* phead)
{
assert(pt && phead);
if (phead==phead->_next) //判断有没有用户信息可以查找
{
printf("没有用户的信息!\n");
return;
}
InfoNode_List* node = phead->_next;
int len = 0;
while (node!=phead)
{
int key = 0;
len = strlen(node->_ListInfo->_telephone);
while (len) //计算权值
{
key += (int)node->_ListInfo->_telephone[len - 1];
key %=MAX_TELEARR; //除留余数法 除数为链的高度
len--;
}
//建立一个新的链节点
HTTele* Newnode = (HTTele*)malloc(sizeof(HTTele));
Newnode->_TeleInfo = node->_ListInfo; //用户信息的复制
Newnode->next = NULL;
if (!pt->_TeleArr[key].next) //如果该位置的头没有地址
{
pt->_TeleArr[key].next = Newnode;
}
else
{
//在当前链的头进行插入
Newnode->next=pt->_TeleArr[key].next;
pt->_TeleArr[key].next = Newnode;
}
node = node->_next;
}
ProgressBar(); //模拟进度条
printf("电话号码哈希链建立完毕\n");
SleepCls(); //0.5秒睡眠+清屏
}
//电话号码查找用户
InfoNode* FindTeleListH(TeleListH* pt, const char* telephone)
{
assert(pt);
int key = 0;
int len = strlen(telephone);
while (len) //计算权值
{
key += (int)telephone[len - 1];
key %= MAX_TELEARR; //除留余数法 除数为链的高度
len--;
}
if (!pt->_TeleArr[key].next)
{
printf("没有找到该用户\n");
return NULL;
}
else
{
HTTele* Newnode = pt->_TeleArr[key].next;
while (Newnode)
{
if (strcmp(Newnode->_TeleInfo->_telephone, telephone) == 0)
{
ShowOnce(Newnode->_TeleInfo); //打印要查找的该用户信息
return Newnode->_TeleInfo; //函数返回该用户的信息节点
}
Newnode = Newnode->next;
}
}
printf("没有找到该用户\n");
return NULL;
}
//修改用户信息
void ChangeTeleListH(TeleListH* pt)
{
assert(pt);
printf("请输入要修改用户的电话号码-->");
char tele[MAX_T];
scanf("%s", tele);
InfoNode* Newnode=FindTeleListH(pt, tele);
system("pause"); //程序暂停,按任意键继续
if (!Newnode) //如果查找函数返回值为NULL,表示未找到,直接返回
{
return;
}
SleepCls();
printf("请重新输入该用户的信息:\n");
ChangeNode(Newnode); //重新输入该用户的新的所有信息
}
text.c
#include "list.h"
#include"hashname.h"
#include "hashtele.h"
void menuFind()
{
printf("-----------------------------------------\n");
printf("|\t查找用户信息-->1\t\t|\n");
printf("-----------------------------------------\n");
printf("|\t修改用户信息-->2\t\t|\n");
printf("-----------------------------------------\n");
printf("您的选择-->");
}
void menu()
{
system("color 3");
printf("\t _______________________________________\n");
printf("\t|\t散列表电话号码查询系统\t\t|\n");
printf("\t|\t 1.增加用户信息\t\t|\n");
printf("\t|\t 2.删除用户信息\t\t|\n");
printf("\t|\t 3.用户名查找和修改用户信息 |\n");
printf("\t|\t 4.电话号码查找和修改用户信息\t|\n");
printf("\t|\t 5.用户信息载入文件\t\t|\n");
printf("\t|\t 6.从文件中读取用户信息\t|\n");
printf("\t|\t 7.对用户信息进行排序\t\t|\n");
printf("\t|\t 8.打印所有用户信息\t\t|\n");
printf("\t|\t 0.退出\t\t\t|\n");
printf("\t|_______________________________________|\n\n");
}
int main()
{
int input=1;
int choose;
InfoNode_List* head; //建立双向循环链表的头结点
head = (InfoNode_List*)malloc(sizeof(InfoNode_List));
InitList(head); //初始化链表
ReadFileInfo(head); //读取文件信息 系统开始时自动读取文件中的信息
printf("\n信息读取完毕,即将进入主页面\n");
ProgressBar(); //模拟进度条载入
SleepCls(); //0.5秒睡眠加清屏
while (1)
{
menu();
printf("请输入您的选择:--> ");
scanf("%d", &choose); //choose表示外部菜单的选项
getchar(); //处理掉用户输入后的回车字符
printf("\n即将执行您的选择");
SleepCls(); //0.5秒睡眠加清屏
switch (choose)
{
case 1:
{
char isagain = 'y';
while (isagain == 'y' || isagain == 'Y')
{
printf("请输入需要增加的用户信息:\n");
printf("----------------------------------\n");
AddList(head); //增加用户信息
printf("是否继续输入用户信息(y或者Y)-->");
getchar(); //处理掉用户输入后的回车字符
scanf("%c", &isagain);
SleepCls();
}
break;
}
case 2:
DeleteListNode(head); //删除用户信息
break;
case 3: //用户名查找和修改用户信息
{
NameTableH* HTname;
HTname = (NameTableH*)malloc(sizeof(NameTableH));
InitNameTableH(HTname); //初始化姓名散列表
SetNameTableH(HTname, head); //建立散列表
menuFind(); //打印查找菜单
scanf("%d", &input); //input 内部菜单的选项
switch (input)
{
case 1: //查找
{
printf("请输入要查寻用户的姓名:");
char name[MAX_N] = "\0";
scanf("%s", name);
FindNameTableH(HTname, name);//姓名查找函数
break;
}
case 2: //修改
ChangeNameTableH(HTname); //先查找再修改
break;
}
break;
}
case 4: //电话号码查找和修改用户信息
{
TeleListH* HTTele; //电话号码哈希表的结构体
HTTele = (TeleListH*)malloc(sizeof(TeleListH));
InitTeleListH(HTTele); //初始化
SetTeleListH(HTTele, head); //建立电话号码哈希表
menuFind(); //打印查找菜单
scanf("%d", &input); //input 内部菜单的选项
switch (input)
{
case 1: //查找
printf("请输入要查寻用户的电话号码:");
char telephone[MAX_T] = { '\0' };
scanf("%s", telephone);
FindTeleListH(HTTele, telephone); //电话号码查找
break;
case 2: //修改
ChangeTeleListH(HTTele); //先查找再修改
break;
}
break;
}
case 5:
WriteFileInfo(head); //写入文件
break;
case 6:
ReadFileInfo(head); //读取文件信息
break;
case 7:
InsertSort(head); //插入排序
break;
case 8:
ShowInfo(head); //打印所有信息
break;
default:
WriteFileInfo(head); //写入文件 程序结束对输入的信息进行文件保护
printf("\n感谢使用~\n");
return 0;
}
if (choose != 1)
{
system("pause");
SleepCls();
}
}
}
//void text1(InfoNode_List* phead)
//{
// InitList(phead); //初始化
// ReadFileInfo(phead);
// AddList(phead); //增加用户信息
// DeleteListNode(phead); //删除用户信息
// BubbleSort(phead);
// WriteFileInfo(phead);
// ShowInfo(phead);
//}
//
//void text2(InfoNode_List* phead)
//{
// NameTableH* HTname;
// HTname = (NameTableH*)malloc(sizeof(NameTableH));
//
// InitNameTableH(HTname);//初始化姓名哈希表
// SetNameTableH(HTname, phead);
// char name[MAX_N] = "duchenlong";
// FindNameTableH(HTname, name);
// ChangeNameTableH(HTname);
//}
//
//void text3(InfoNode_List* phead)
//{
// TeleListH* HTTele;
// HTTele = (TeleListH*)malloc(sizeof(TeleListH));
// InitTeleListH(HTTele);
// SetTeleListH(HTTele,phead);
// char telephone[MAX_T] = "13325430774";
// FindTeleListH(HTTele,telephone);
// ChangeTeleListH(HTTele);
//}
//int main()
//{
// InfoNode_List* head;
// head = (InfoNode_List*)malloc(sizeof(InfoNode_List));
// text1(head); //链表调试测试接口
// //text2(head); //姓名为关键字哈希表的测试接口
// text3(head);
// return 0;
//}
模拟进度条和加载
开始界面