数据结构C语言版稀疏矩阵的三元组顺序表存储表示和实现.doc

数据结构C语言版稀疏矩阵的三元组顺序表存储表示和实现
(可以直接使用，可编辑 优质资料，欢迎下载）

typedef int ElemType;

// 稀疏矩阵的三元组顺序表存储表示

#define MAXSIZE 100 // 非零元个数的最大值
typedef struct
{
int i,j;// 行下标,列下标
ElemType e; // 非零元素值
}Triple;

typedef struct
{
Triple data[MAXSIZE+1]; // 非零元三元组表,data[0]未用
int mu,nu,tu;// 矩阵的行数、列数和非零元个数
}TSMatrix;

// 创建稀疏矩阵M
int CreateSMatrix(TSMatrix *M)
{
int i,m,n;
ElemType e;
int k;

printf("请输入矩阵的行数,列数,非零元素个数：（逗号）\n");
scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu);
(*M).data[0].i=0;// 为以下比较顺序做准备
for(i = 1; i <= (*M).tu; i++)
{
do
{
printf("请按行序顺序输入第%d个非零元素所在的行(1～%d),"
"列(1～%d),元素值：(逗号)\n", i,(*M).mu,(*M).nu);
scanf("%d,%d,%d",&m,&n,&e);
k=0;
// 行或列超出范围
if(m < 1 || m > (*M).mu || n < 1 || n > (*M).nu)
k=1;
if(m < (*M).data[i-1].i || m == (*M).data[i-1].i
&& n <= (*M).data[i-1].j) // 行或列的顺序有错
k=1;
}while(k);
(*M).data[i].i = m;//行下标
(*M).data[i].j = n;//列下标
(*M).data[i].e = e;//该下标所对应的值
}
return 1;
}

// 销毁稀疏矩阵M，所有元素置空
void DestroySMatrix(TSMatrix *M)
{
(*M).mu=0;
(*M).nu=0;
(*M).tu=0;
}

// 输出稀疏矩阵M
void PrintSMatrix(TSMatrix M)
{
int i;
printf("\n%d行%d列%d个非零元素。\n",M.mu,M.nu,M.tu);
printf("%4s%4s%8s\n", "行", "列", "元素值");
for(i=1;i<=M.tu;i++)
printf("%4d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e);
}

// 由稀疏矩阵M复制得到T
int CopySMatrix(TSMatrix M,TSMatrix *T)
{
(*T)=M;
return 1;
}

// AddSMatrix函数要用到
int comp(int c1,int c2)
{
int i;
if(c1<c2)
i=1;
else if(c1==c2)
i=0;
else
i=-1;
return i;
}

// 求稀疏矩阵的和Q=M+N
int AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q)
{
Triple *Mp,*Me,*Np,*Ne,*Qh,*Qe;
if(M.mu!=N.mu)
return 0;
if(M.nu!=N.nu)
return 0;
(*Q).mu=M.mu;
(*Q).nu=M.nu;
Mp=&M.data[1];// Mp的初值指向矩阵M的非零元素首地址
Np=&N.data[1];// Np的初值指向矩阵N的非零元素首地址
Me=&M.data[M.tu];// Me指向矩阵M的非零元素尾地址
Ne=&N.data[N.tu];// Ne指向矩阵N的非零元素尾地址
Qh=Qe=(*Q).data;// Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址
while(Mp <= Me && Np <= Ne)
{
Qe++;
switch(comp(Mp->i,Np->i))
{
case 1:
*Qe=*Mp;
Mp++;
break;
case 0:
// M、N矩阵当前非零元素的行相等,继续比较列
switch(comp(Mp->j,Np->j))
{
case 1:
*Qe=*Mp;
Mp++;
break;
case 0:
*Qe=*Mp;
Qe->e+=Np->e;
if(!Qe->e) // 元素值为0，不存入压缩矩阵
Qe--;
Mp++;
Np++;
break;
case -1:
*Qe=*Np;
Np++;
}
break;
case -1:
*Qe=*Np;
Np++;
}
}
if(Mp>Me) // 矩阵M的元素全部处理完毕
while(Np<=Ne)
{
Qe++;
*Qe=*Np;
Np++;
}
if(Np>Ne) // 矩阵N的元素全部处理完毕
while(Mp<=Me)
{
Qe++;
*Qe=*Mp;
Mp++;
}
(*Q).tu=Qe-Qh; // 矩阵Q的非零元素个数
return 1;
}

// 求稀疏矩阵的差Q=M-N
int SubtSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q)
{
int i;
for(i=1;i<=N.tu;i++)
N.data[i].e*=-1;
AddSMatrix(M,N,Q);
return 1;
}

// 求稀疏矩阵的乘积Q=M*N
int MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q)
{
int i,j,h=M.mu,l=N.nu,Qn=0;
// h,l分别为矩阵Q的行、列值,Qn为矩阵Q的非零元素个数，初值为0
ElemType *Qe;
if(M.nu!=N.mu)
return 0;
(*Q).mu=M.mu;
(*Q).nu=N.nu;
Qe=(ElemType *)malloc(h*l*sizeof(ElemType)); // Qe为矩阵Q的临时数组
// 矩阵Q的第i行j列的元素值存于*(Qe+(i-1)*l+j-1)中，初值为0
for(i=0;i<h*l;i++)
*(Qe+i)=0; // 赋初值0
for(i=1;i<=M.tu;i++) // 矩阵元素相乘，结果累加到Qe
for(j=1;j<=N.tu;j++)
if(M.data[i].j==N.data[j].i)
*(Qe+(M.data[i].i-1)*l+N.data[j].j-1) +=
M.data[i].e * N.data[j].e;
for(i=1;i<=M.mu;i++)
for(j=1;j<=N.nu;j++)
if(*(Qe+(i-1)*l+j-1)!=0)
{
Qn++;
(*Q).data[Qn].e=*(Qe+(i-1)*l+j-1);
(*Q).data[Qn].i=i;
(*Q).data[Qn].j=j;
}
free(Qe);
(*Q).tu=Qn;
return 1;
}

// 算法5.1 P99
// 求稀疏矩阵M的转置矩阵T。
int TransposeSMatrix(TSMatrix M,TSMatrix *T)
{
int p,q,col;
(*T).mu=M.nu;
(*T).nu=M.mu;
(*T).tu=M.tu;
if((*T).tu)
{
q=1;
for(col=1;col<=M.nu;++col)//先将列转换成行
for(p=1;p<=M.tu;++p)//再将行转换成列
if(M.data[p].j==col)
{
(*T).data[q].i=M.data[p].j;
(*T).data[q].j=M.data[p].i;
(*T).data[q].e=M.data[p].e;
++q;
}
}
return 1;
}

// 算法5.2 P100
// 快速求稀疏矩阵M的转置矩阵T。
int FastTransposeSMatrix(TSMatrix M,TSMatrix *T)
{
int p,q,t,col,*num,*cpot;
num=(int *)malloc((M.nu+1)*sizeof(int));// 生成数组（[0]不用）
cpot=(int *)malloc((M.nu+1)*sizeof(int));// 生成数组（[0]不用）
(*T).mu=M.nu;
(*T).nu=M.mu;
(*T).tu=M.tu;
if((*T).tu)
{
for(col=1;col<=M.nu;++col)
num[col]=0; // 设初值
for(t=1;t<=M.tu;++t) // 求M中每一列含非零元素个数
++num[M.data[t].j];
cpot[1]=1;
// 求第col列中第一个非零元在(*T).data中的序号
for(col=2;col<=M.nu;++col)
cpot[col]=cpot[col-1]+num[col-1];
for(p=1;p<=M.tu;++p)
{
col=M.data[p].j;
q=cpot[col];
(*T).data[q].i=M.data[p].j;
(*T).data[q].j=M.data[p].i;
(*T).data[q].e=M.data[p].e;
++cpot[col];
}
}
free(num);
free(cpot);
return 1;
}

int main()
{
TSMatrix A,B,C;

printf("创建矩阵A: ");
CreateSMatrix(&A);
PrintSMatrix(A);

printf("由矩阵A复制矩阵B: ");
CopySMatrix(A,&B);
PrintSMatrix(B);

DestroySMatrix(&B);
printf("销毁矩阵B后:\n");
PrintSMatrix(B);

printf("重创矩阵B:(注意与矩阵A的行、列数相同，这样方便后面的测试"
"行、列分别为%d,%d)\n", A.mu, A.nu);
CreateSMatrix(&B);
PrintSMatrix(B);

printf("矩阵C1(A+B): ");
AddSMatrix(A,B,&C);
PrintSMatrix(C);
DestroySMatrix(&C);

printf("矩阵C2(A-B): ");
SubtSMatrix(A,B,&C);
PrintSMatrix(C);
DestroySMatrix(&C);

printf("矩阵C3(A的转置): ");
TransposeSMatrix(A,&C);
PrintSMatrix(C);
DestroySMatrix(&A);
DestroySMatrix(&B);
DestroySMatrix(&C);

printf("创建矩阵A2: ");
CreateSMatrix(&A);
PrintSMatrix(A);

printf("创建矩阵B3:(行数应与矩阵A2的列数相同=%d)\n",A.nu);
CreateSMatrix(&B);
PrintSMatrix(B);

printf("矩阵C5(A*B): ");
MultSMatrix(A,B,&C);
PrintSMatrix(C);
DestroySMatrix(&A);
DestroySMatrix(&B);
DestroySMatrix(&C);

printf("创建矩阵A: ");
CreateSMatrix(&A);
PrintSMatrix(A);

FastTransposeSMatrix(A,&B);
printf("矩阵B(A的快速转置): ");
PrintSMatrix(B);

DestroySMatrix(&A);
DestroySMatrix(&B);

system("pause");
return 0;
}

/*
输出效果：

创建矩阵A: 请输入矩阵的行数,列数,非零元素个数：（逗号）
3,3,3
请按行序顺序输入第1个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
1,1,1
请按行序顺序输入第2个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
1,3,2
请按行序顺序输入第3个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
3,3,3

3行3列3个非零元素。
行 列 元素值
1 1 1
1 3 2
3 3 3
由矩阵A复制矩阵B:
3行3列3个非零元素。
行 列 元素值
1 1 1
1 3 2
3 3 3
销毁矩阵B后:

0行0列0个非零元素。
行 列 元素值
重创矩阵B:(注意与矩阵A的行、列数相同，这样方便后面的测试行、列分别为3,3)
请输入矩阵的行数,列数,非零元素个数：（逗号）
3,3,3
请按行序顺序输入第1个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
1,2,1
请按行序顺序输入第2个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
2,1,2
请按行序顺序输入第3个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
3,1,3

3行3列3个非零元素。
行 列 元素值
1 2 1
2 1 2
3 1 3
矩阵C1(A+B):
3行3列6个非零元素。
行 列 元素值
1 1 1
1 2 1
1 3 2
2 1 2
3 1 3
3 3 3
矩阵C2(A-B):
3行3列6个非零元素。
行 列 元素值
1 1 1
1 2 -1
1 3 2
2 1 -2
3 1 -3
3 3 3
矩阵C3(A的转置):
3行3列3个非零元素。
行 列 元素值
1 1 1
3 1 2
3 3 3
创建矩阵A2: 请输入矩阵的行数,列数,非零元素个数：（逗号）
3,3,3
请按行序顺序输入第1个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
1,1,1
请按行序顺序输入第2个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
1,3,2
请按行序顺序输入第3个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
3,3,3

3行3列3个非零元素。
行 列 元素值
1 1 1
1 3 2
3 3 3
创建矩阵B3:(行数应与矩阵A2的列数相同=3)
请输入矩阵的行数,列数,非零元素个数：（逗号）
3,3,2
请按行序顺序输入第1个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
1,3,1
请按行序顺序输入第2个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
2,2,2

3行3列2个非零元素。
行 列 元素值
1 3 1
2 2 2
矩阵C5(A*B):
3行3列1个非零元素。
行 列 元素值
1 3 1
创建矩阵A: 请输入矩阵的行数,列数,非零元素个数：（逗号）
3,3,2
请按行序顺序输入第1个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
1,2,2
请按行序顺序输入第2个非零元素所在的行(1～3),列(1～3),元素值：(逗号)
3,1,2

3行3列2个非零元素。
行 列 元素值
1 2 2
3 1 2
矩阵B(A的快速转置):
3行3列2个非零元素。
行 列 元素值
1 3 2
2 1 2
请按任意键继续. . .

*/
目录
1 选题背景2
2 方案与论证3
2.1 链表的概念和作用3
2.3 算法的设计思想4
2.4 相关图例5
2.4.1 单链表的结点结构5
2.4.2 算法流程图5
3 实验结果6
3.1 链表的建立6
3.2 单链表的插入6
3.3 单链表的输出7
3.4 查找元素7
3.5 单链表的删除8
3.6 显示链表中的元素个数（计数）9
4 结果分析10
4.1 单链表的结构10
4.2 单链表的操作特点10
4.2.1 顺链操作技术10
4.2.2 指针保留技术10
4.3 链表处理中的相关技术10
5 设计体会及今后的改进意见11
参考文献12
附录代码：13

1 选题背景
陈火旺院士把计算机60多年的发展成就概括为五个“一”：开辟一个新时代----信息时代，形成一个新产业----信息产业，产生一个新科学----计算机科学与技术，开创一种新的科研方法----计算方法，开辟一种新文化----计算机文化，这一概括深刻影响了计算机对社会发展所产生的广泛而深远的影响。
数据结构和算法是计算机求解问题过程的两大基石。著名的计算机科学家P.Wegner指出，“在工业革命中其核心作用的是能量，而在计算机革命中其核心作用的是信息”。计算机科学就是“一种关于信息结构转换的科学”。信息结构（数据结构）是计算机科学研究的基本课题，数据结构又是算法研究的基础。

2 方案与论证
2.1 链表的概念和作用
链表是一种链式存储结构，链表属于线性表，采用链式存储结构，也是常用的动态存储方法。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
以“结点的序列”表示线性表称作线性链表（单链表）
单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。
因此，查找第 i 个数据元素的基本操作为：移动指针，比较 j 和 i
单链表
1、链接存储方法
链接方式存储的线性表简称为链表（Linked List）。
链表的具体存储表示为：
① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）
② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）
注意：
链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。
2、链表的结点结构
┌───┬───┐
│data │next │
└───┴───┘
data域--存放结点值的数据域
next域--存放结点的直接后继的地址（位置）的指针域（链域）
注意：
①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。
②每个结点只有一个链域的链表称为单链表（Single Linked List）。
3、头指针head和终端结点指针域的表示
单链表中每个结点的存储地址是存放在其前趋结点next域中，而开始结点无前趋，故应设头指针head指向开始结点。
注意：
链表由头指针唯一确定，单链表可以用头指针的名字来命名。
终端结点无后继，故终端结点的指针域为空，即NULL。
2.2 实验的基本要求（软硬件）
用VC++6.0软件平台，操作系统：Windows XP 硬件：内存要求：内存大小在256MB，其他配置一般就行。
2.3 算法的设计思想
（a）定义一个创建链表的函数，通过该头插法创建一个带头结点的链表，在接下来的链表操作中使用。
（b）定义输出链表的算法 ，遍历结点的指针域判断是否为空，如果不为空则输出其数据域，直到指针域为空为止。
（c）定义一个遍历查找的算法，通过遍历的数据域，分别与要查询的元素进行比较，如果查找到则返回并输出，如入查找失败则返回错误提示信息。
（d）定义插入结点的算法，首先查找指针域为空的结点，并申请空间插入在结点的后边，并且将其指针域置空。
（e）定义删除节点的操作，这个算法用于对链表中某个多余节点的删除工作，其关键在于前驱结点的保留，查找到需删除的结点，将其删除，并将其后继结点连到其前驱结点。

2.4 相关图例
2.4.1 单链表的结点结构
如图2-1所示,为单链表的结点结构示意图：
Data域 Next域

图2-1 单链表的结点结构
2.4.2 算法流程图
如图2-2所示，为此算法流程图：
开始

定义结构体Node
构建各种对链表操作的函数（插入、删除、查找、输出），并写出相应的算法及实现过程

创建一个单链表，用于之前所定义的函数对其进行操作
按要求输出结果
结束

图2-2 算法流程图

3 实验结果
3.1 链表的建立

图 3-1 链表的建立

3.2 单链表的插入

图3- 2单链表的插入
3.3 单链表的输出

图3-3 输出单链表元素

3.4 查找元素

图3-4查找成功

图3-5 查找失败
3.5 单链表的删除

图3-6 删除成功

图3-6 删除失败

3.6 显示链表中的元素个数（计数）

图3-7输出长度

4 结果分析
4.1 单链表的结构
一般情况下，使用链表，只关心链表中结点间的逻辑顺序，并不关心每个结点的实际存储位置，因此通常情况下用箭头来表示链域中的指针，于是链表就可以更直观的画成用箭头链接起来的结点序列，如下图所示：
A
B
C
D
E ^

H

图4-1 单链表的示例图
4.2 单链表的操作特点
4.2.1 顺链操作技术
从“头”开始，访问单链表L中的结点i（p指向该节点）时，由于第i个结点的地址在第i-1个结点（pre指向该结点，为p的前驱）的指针域中存放，查找必须从单链表的“首结点”开始（p=L）；通过p=p->next并辅助计数器来实现。
4.2.2 指针保留技术
通过对第i个结点进行插入、删除等操作时，需要对第i-1个结点的指针域进行链址操作（pre->next），因此在处理过程中始终需要维持当前指针p与其前驱指针pre的关系，将这种技术称为“指针保留技术”。
4.3 链表处理中的相关技术
1）单链表与多重链表的差别在于指针域的个数。
2）判断当前结点p是否为表尾。一半链表中，p结点是表尾的条件是：该节点的后继结点为空指针，即p->next==NULL;
3）链表的长度并未显示保存。由于链表是动态生成的结构，其长度要通过顺链查找到表尾得到。因此在处理链表时，往往是以当前处理结点p是否为表尾作为控制条件，而不是长度n作为控制条件。

5 设计体会及今后的改进意见
通过这次实验加深了我对于单链表的进一步了解，了解到了单链表在内存中的存储结构，最重要的是学会了如何运用C语言将单链表的建立，插入、删除、添加等操作。在程序实现中也遇到了一些困难，在单链表初始化时，使用了0作为结束输入符，导致单链表不能存储数据0；单链表中只能存储相同类型的数据，在存储不同类型的数据时需要改变输入结束标志，程序通用性比较差。
在进行程序设计的时候没有考虑好删除和查找的方式，只进行了输入元素的查找和删除，而且进行链表的插入时，只考虑了头插法在结尾插入，而没有考虑输入结点插入等，程序的灵活性比较低。
通过这次课程设计，让我充分认识到数据结构在编写程序方面的重要地位。
不仅仅是单链表的操作，还有栈和队列等特殊的单链表操作，以及其他一些常用的数据结构对于程序的效率和内存使用有很大的帮助。我希望在接下来的学习中收获更多的东西。
参考文献
[1]耿国华.数据结构--用C语言描述[M].北京:高等教育出版社,2021.6.
[2]谭浩强.C程序设计[M].北京:清华大学出版社,2004.6.

附录代码：
结构体定义：
#pragmaonce
#include<stdio.h>
#include<stdlib.h>

enummy_enum
{
_EXIT,
_CREATE,
_INSERT,
_PRINT,
_SEARCH,
_DELETE,
_COUNT,
};

staticint count = 0;
typedefintElemtype;

typedefstructNode/*单链表结构体的定义*/
{
Elemtype data;
structNode *next;
}
Node, *LinkList;

void test();/*测试函数*/
void main_menu();//主菜单函数
void CreatFromHead(LinkList *l);/*头插法建立单链表*/
void Insert(LinkList l);//单链表的插入
void Print(LinkList l);/*单链表的输出*/
int Search(LinkList l, Elemtype e);//查找指定的元素
void Deletelist(LinkList l, Elemtype e);//删除元素
void Count();//计数
void CREATE(LinkList *head);
void INSERT(LinkList *head);
void PRINT(LinkList *head);
void SEARCH(LinkList* head);
void DELET(LinkList *head);
void COUNT();
单链表操作函数：

#define_CRT_SECURE_NO_WARNINGS
#include"linklist.h"

void main_menu()
{
printf("\t 单链表的简单操作\t\t\n\n");
printf("\t 1 单链表的建立\n");
printf("\t 2 单链表的插入\n");
printf("\t 3 单链表的输出\n");
printf("\t 4 单链表的查找\n");
printf("\t 5 单链表的删除\n");
printf("\t 6 单链表的长度\n");
printf("\t 0 退出\n");
}
void CreatFromHead(LinkList *l)/*头插法建立单链表*/
{
Node *s;
int c = 0;
int flag = 1;
*l = (Node*)malloc(sizeof(Node));
if (*l == NULL)
{
printf("申请空间失败！！\n");
return;
}
(*l)->next = NULL;
while (flag)
{
scanf("%d", &c);
if (c != 0)
{
s = (Node*)malloc(sizeof(Node));
if (s == NULL)
{
printf("申请空间失败！！\n");
return;
}
s->data = c;
s->next = (*l)->next;
(*l)->next = s;
count++;
}
else flag = 0;
}
}
void Insert(LinkListl)//单链表的插入
{
int insert = 0;
Node * s = NULL;
printf("请输入需要插入的元素：");
scanf("%d", &insert);
s = (Node*)malloc(sizeof(Node));
if (s == NULL)
{
printf("申请空间失败！！\n");
return;
}
while (l->next != NULL)
{
l = l->next;
}
s->data = insert;
s->next = l->next;
l->next = s;
count++;
}
void Print(LinkListl)/*单链表的遍历*/
{
Node *p;
p = l->next;
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
int Search(LinkListl, Elemtypee)//查找指定的元素
{
while ((l != NULL) && (l->data != e))
{
l = l->next;
}
if (l == NULL)
{
return -1;//查找失败
}
else
{
return 1;//查找成功
}
}
void Deletelist(LinkListl, Elemtypee)//删除节点
{
Node *p, *r, *q;
p = l->next; q = l;
while (p != NULL)
{
if (p->data == e)
{
r = p;
p = r->next;
q->next = p;
count--;
free(r);
break;
}
else
{
q = p;/*保留前驱节点*/
p = p->next;
}
}
if (p == NULL)
{
printf("删除失败，没有找到相应的元素\n");
}
}
void Count()
{
printf("单链表中一共有%d个元素\n", count);
}

void CREATE(LinkList *head)
{
printf("请建立单链表用“0”来结束输入\n");
CreatFromHead(head);
printf("初始化后的单链表为：");
Print(*head);
}
void INSERT(LinkList *head)
{
Insert(*head);
printf("插入后的单链表为：");
Print(*head);
}
void PRINT(LinkList *head)
{
printf("单链表的输出为：");
Print(*head);
}
void SEARCH(LinkList *head)
{
int search = 0;
int ret = 0;
printf("请输入需要查找的元素：");
scanf("%d", &search);
ret = Search(*head, search);
if (1 == ret)
{
printf("查找成功\n");
}
else
{
printf("查找失败\n");
}
}
void DELET(LinkList *head)
{
int delet = 0;
printf("请输入需要删除的元素：");
scanf("%d", &delet);
Deletelist(*head, delet);
printf("删除之后的单链表为：");
Print(*head);
}

void COUNT()
{
Count();
}
主菜单函数：

#define_CRT_SECURE_NO_WARNINGS

#include"linklist.h"

int main()/*主函数*/
{
test();
return 0;
}

void test()//测试函数
{
int input = 1;
Node * head = NULL;
main_menu();
while (input != _EXIT)
{
scanf("%d", &input);
switch (input)
{
case _CREATE:
{
CREATE(&head);//创建
break;
}
case _INSERT:
{
INSERT(&head);//插入
break;
}
case _PRINT:
{
PRINT(&head);//输出
break;
}
case _SEARCH:
{
SEARCH(&head);//查找
break;
}
case _DELETE:
{
DELET(&head);//删除
break;
}
case _COUNT:
{
COUNT();//计数
break;
}
case _EXIT:
{
exit(0);//退出
break;
}
default:
{
break;
}
}
main_menu();
}
free(head);
}

//要求用C语言完成课程设计 职工信息管理系统—单链表实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int saveflag=0; /*是否需要存盘的标志变量*/

struct employee
{
char name[15];
char num[10];/* 工号 *