c链表的基本操作（顺序表和链表的基本操作，用C语言实现！）

本文目录

• 顺序表和链表的基本操作，用C语言实现！
• 编写一个C语言程序 实现单链表的基本操作
• 用C语言编写线性链表的删除，插入，逆置等基本操作
• C语言链表操作
• C语言单向链表的创建，输入，插入和删除的实现
• 链表基本操作练习（C语言）

顺序表和链表的基本操作，用C语言实现！

顺序存储的线性表的算法
#include "stdio.h"
#include "stdlib.h"
#define Status int
#define OVERFLOW 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXSIZE 100
typedef int ElemType;
typedef struct list
{ElemType elem;
int length;
}SqList;
void InitList(SqList &L){
L.length=0;
}
/*建立顺序表*/
void CreateList(SqList &L)
{
int i;
printf("input the length");
scanf("%d",&L.length);//输入表长
for(i=1;i《=L.length;i++)
scanf("%d",&L.elem);//输入元素
}
//顺序表的遍历
void printdata(ElemType e){
printf("%4d",e);
}
void Traverse(SqList L,void (*visit)(ElemType e))
{ int i;
printf("The elements of the lists are:\n");
for(i=1;i《=L.length;i++){
if (i%10==0)printf("\n");//每行显示10个元素
visit(L.elem);//输出表中元素
}
printf("\n");
}

//有序顺序表L中插入元素e使序列仍有序
void Insert(SqList &L,ElemType e)
{int i,j;
if (L.length==MAXSIZE)exit(OVERFLOW);//表满,不能插入
for(i=1;i《=L.length&&L.elem《=e;i++);//向后查找
for(j=L.length;j》=i;j--)
L.elem;//元素后移
L.elem=e;//插入e
L.length=L.length+1;//表长加1
}
//建立递增有序的顺序表
void CreateList_Sorted(SqList &L)
{int i,num;
ElemType e;
L.length=0;
printf("Create a sorted list,Input the length of the list\n");
scanf("%d",#);
printf("Input the data %d numbers\n",num);
for(i=1;i《=num;i++){
scanf("%d",&e);
Insert(L,e);
}
}
/*Merge two sorted lists*/
void MergeList(SqList La,SqList Lb,SqList &Lc)
{int *pa,*pb,*pc;
if (La.length+Lb.length》MAXSIZE) exit(OVERFLOW);
else
{pa=La.elem;pb=Lb.elem;pc=Lc.elem;
while (pa《La.elem+La.length&&pb《Lb.elem+Lb.length)
*pc++=(*pa《=*pb)?*pa++:*pb++;/*公共部分合并*/
while (pa《La.elem+La.length) *pc++=*pa++;
/*R1表的剩余部分放到R的后部*/
while (pb《Lb.elem+Lb.length) *pc++=*pb++;
/*R2表的剩余部分放到R的后部*/
Lc.length=La.length+Lb.length;/*R表长*/
}
}
//判断元素是否对称，对称返回TRUE 否则返回FALSE
Status Symmetric(SqList L)
{int low,high;
low=0;
high=L.length-1;
while(low《high)
if (L.elem){low++;high--;}
else return(FALSE); return(TRUE); }
//顺序表的主函数部分
//#include "seqlist.h"
void main()
{SqList L1,L2,L;
int select;
ElemType e;
do{printf("\n1 insert 2 merge");
printf("\n3 symmetric 0 exit \n");
printf("Please select(0--3)\n");
scanf("%d",&select);
switch(select){
case 1:
InitList(L);
CreateList_Sorted(L);
Traverse(L,printdata);
printf("\nInput the element of inserted\n");
scanf("%d",&e);
Insert(L,e);
Traverse(L,printdata);
break;
case 2:
InitList(L1);
CreateList_Sorted(L1);
Traverse(L1,printdata);
InitList(L2);
CreateList_Sorted(L2);
Traverse(L2,printdata);
InitList(L);
MergeList(L1,L2,L);
Traverse(L,printdata);
break;
case 3:
InitList(L);
CreateList(L);
Traverse(L,printdata);
if (Symmetric(L)) printf("Yes!\n"); else printf("Not\n");
break;
case 0:break;
default:printf("Error! Try again!\n");
}
}while(select);
}
/*单向链表的有关操作示例*/
/*类型定义及头文件部分,文件名为sllink.h*/
#include 《stdio.h》
#include 《stdlib.h》
typedef int ElemType;//元素实际类型
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList; //定义结点、指针类型名
//头插法建立无序链表
void CreateList(LinkList &L){
LinkList p;
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L-》next=NULL;
printf("头插法建立链表，以0结束\n");
scanf("%d",&e);
while(e){
p=(LinkList)malloc(sizeof(LNode));
p-》data=e;
p-》next=L-》next;
L-》next=p;
scanf("%d",&e);
}
}
/*非递减有序单向链表L插入元素e序列仍有序*/
void Insert_Sort(LinkList &L,ElemType e){
LinkList p,s;
s=(LinkList)malloc(sizeof(LNode));
s-》data=e;
p=L;
while(p-》next&&p-》next-》data《=e)
p=p-》next;/*查找插入位置*/
s-》next=p-》next; /*插入语句*p结点后插入*s结点*/
p-》next=s;
}
/*建立递增有序的单向链表*/
void Create_Sort(LinkList &L){
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L-》next=NULL;
printf("建立有序表，输入任意个整型数据以0结束\n");
scanf("%d",&e);
while(e){
Insert_Sort(L,e);
scanf("%d",&e);
}
}
/*单向链表的遍历*/
void Traverse(LinkList L){
LinkList p;
printf("遍历链表");
for(p=L-》next;p;p=p-》next)
printf("%5d",p-》data);
printf("\n");
}
/*在单向链表删除元素e*/
void Delete(LinkList &L,ElemType e){
LinkList p,q;
p=L;
q=L-》next;
while(q&& q-》data!=e){//查找元素的删除位置
p=q;
q=q-》next;
}
if(!q) printf("\nnot deleted");/*未找到元素e*/
else {p-》next=q-》next;/*找到删除*/
****(q);}
}
/*单向链表的逆置*/
void exch(LinkList &L){
LinkList p,s;
p=L-》next;
L-》next=NULL;
while(p){
s=p;
p=p-》next;
s-》next=L-》next;
L-》next=s;
}
}
/*两个非递减有序单向链表合并后仍为非递减序列*/
void MergeIncrease(LinkList La,LinkList Lb,LinkList &Lc){
LinkList p,q,s,rear;
p=La-》next;
q=Lb-》next;
Lc=rear=La;
****(Lb);
while(p&&q){
if (p-》data《q-》data) {s=p;p=p-》next; }
else {s=q;q=q-》next; }
rear-》next=s;/*较小元素插入表尾*/
rear=rear-》next;
}
if (p) rear-》next=p; else rear-》next=q;
}
/*主函数部分,文件名为sllink.c*/
//#include "sllink.h"
void main(){
LinkList La,Lb,Lc;
ElemType e;
int select;
do{
printf(" 1 建立无序表，再删除指定元素\n");
printf(" 2 建立递增有序表，再逆置\n");
printf(" 3 建立两个递增有序表，将它们和并为一个仍递增表\n");
printf(" 0 退出，请输入选项(0-3)\n");
scanf("%d",&select);
switch(select){
case 0:
break;
case 1:
CreateList(La);
Traverse(La);
printf("输入需删除的元素\n");
scanf("%d",&e);
Delete(La,e);
Traverse(La);
break;
case 2:
Create_Sort(La);
Traverse(La);
exch(La);
printf("The list that is exchaged\n");
Traverse(La);
break;
case 3:
Create_Sort(La);Traverse(La);
Create_Sort(Lb);Traverse(Lb);
MergeIncrease(La,Lb,Lc);Traverse(Lc);
break;
default:
printf("输入选项错误，请重新输入！\n");
}

}while(select);
}
这些内容不知道能不能帮助到你。

编写一个C语言程序 实现单链表的基本操作

# include 《stdio.h》
# include 《malloc.h》
# include 《stdlib.h》
typedef struct Node
{
int data;
struct Node * pNext;
} * PNODE, NODE;
PNODE establish_list (void);
void traverse_list (PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE pHead);
void sort_list(PNODE pHead);
void insert_list(PNODE pHead, int pos, int val);
int delete_list(PNODE pHead, int pos, int val);
void ****er(PNODE pHead);
int main(void)
{
PNODE pHead;
int len, i, j, val;
pHead = establish_list();
traverse_list(pHead);
if(is_empty(pHead))
printf("链表为空\n");
else
printf("链表不空\n");
len = length_list(pHead);
printf("链表的长度为: %d\n", len);
sort_list(pHead);
traverse_list(pHead);
printf("请输入您要在第几个节点插入\n");
scanf("%d", &i);
printf("请输入您要在第%d个节点插入的值\n", i);
scanf("%d", &j);
insert_list(pHead, i, j);
traverse_list(pHead);
printf("请输入您要第几个删除的节点\n");
scanf("%d", &i);
val = delete_list(pHead, i, val);
printf("您删除的节点值为: %d\n", val);
traverse_list(pHead);
****er(pHead);
return 0;
}
PNODE establish_list(void)//初始化链表，返回头结点地址
{
int val, len;
PNODE Tem;
PNODE pNew;
PNODE pHead;
pHead = (PNODE)malloc(sizeof(NODE));
Tem = pHead;
if(NULL == pHead)
{
printf("分配失败");
exit(-1);
}
Tem-》pNext = NULL;
printf("请输入您要定义节点的长度: ");
scanf("%d", &len);

for (int i=0;i《len;++i)
{
printf("请输入第%d个节点的值: ", i+1);
scanf("%d", &val);
pNew = (PNODE)malloc(sizeof(NODE));
if(NULL == pNew)
{
printf("分配失败");
exit(-1);
}
pNew-》data = val;//首先把本次创建的新节点的值付给新节点的数据域
Tem-》pNext = pNew;//然后使用临时的节点变量的指针域保存了新节点的地址，也就是指向了新节点
pNew-》pNext = NULL;//如何再不循环，新节点成为最后一个节点
Tem = pNew;//把本次分配的新节点完全的赋给Tem，Tem就成为了这次新节点的影子,那么下次分配新节点时可以使用上个新节点的数据
}
return pHead;
}
void traverse_list(PNODE pHead)
{
PNODE p = pHead;//使用P是为了不改写头结点里保存的地址
p = pHead-》pNext;//使P指向首节点
while(p != NULL)//P本来就是头结点的指针域，也就是首节点的地址，既然是地址就可以直接判断p是否等于NULL
{
printf("%d ", p-》data);
p = p-》pNext;//使P每循环一次就变成P的下一个节点
}
}
bool is_empty(PNODE pHead)
{
if(NULL == pHead-》pNext)
return true;
else
return false;
}
int length_list(PNODE pHead)
{
PNODE p = pHead-》pNext;
int len = 0;

while(p != NULL)
{
len++;
p = p-》pNext;
}
return len;
}
void sort_list(PNODE pHead)
{
int i, j, t, len;
PNODE p, q;
len = length_list(pHead);

for(i=0,p=pHead-》pNext;i《len;i++,p=p-》pNext)//逗号后只是为了找到下一个节点，因为不是数组，所以不能使用下标来++
{
for(j=0,q=pHead-》pNext;j《len;j++,q=q-》pNext)
if(q-》data 》 p-》data)//这里的大小与号可以决定是升序还是降序，如果是大于号就是升序,反之小于号就是降序
{
t = q-》data;
q-》data = p-》data;
p-》data = t;
}
}

return;
}
void insert_list(PNODE pHead, int pos, int val)
{
int i;
PNODE q = pHead;
PNODE p = pHead;
if(pos 》 0 && pos 《= length_list(pHead))
{
for(i=0;i《pos;i++)
{
q = q-》pNext;//q就是要插入的连接点
}
for(i=1;i《pos;i++)
{
p = p-》pNext;//p就是要插入连接点的前一个节点
}
PNODE pNew = (PNODE)malloc(sizeof(NODE));
p-》pNext = pNew;
pNew-》data = val;
pNew-》pNext = q;
}
else if(pos 》 length_list(pHead))//追加
{
PNODE t;
t = pHead;
PNODE PN;
PN = (PNODE)malloc(sizeof(NODE));
if(PN == NULL)
printf("分配失败");
else
while(t-》pNext != NULL)
{
t = t-》pNext;//使T-》pNext成为尾结点
}
PN-》data = val;//给新节点赋予有效数据
t-》pNext = PN;//使尾结点的指针域指向了新的结点
PN-》pNext = NULL;//新节点成为尾结点
}
else
printf("error\n");
return;
}
int delete_list(PNODE pHead, int pos, int val)
{
int i, j;
PNODE q, p;
q = pHead;
p = pHead;

if(pos 》 0 && pos 《= length_list(pHead))//保证删除的是节点的有效数
{
for(i=0;i《pos;i++)
{
p = p-》pNext;
}
for(j=1;j《pos;j++)
{
if(pos == 0)
q = pHead;
else
q = q-》pNext;
}
q-》pNext = p-》pNext;
val = p-》data;

****(p);
return val;
}
else
printf("error");
}
void ****er(PNODE pHead)
{
PNODE pT = pHead;
while(NULL != pHead-》pNext)
{
****(pT);
pT = pT-》pNext;
}
return;
}
/*
好久以前写的一个链表了，有排序，插入，删除，输出，判断是否为空，甚至还有释放堆中内存的功能
*/

用C语言编写线性链表的删除，插入，逆置等基本操作

这是用C++写的，不知道行不行
#include《iostream.h》
#include《stdlib.h》
typedef int elemtype;
typedef struct node
{
elemtype data;
struct node *next;
}Lnode,*Lklist;
void initLklist(Lklist &h)
{
h-》next =NULL;
}
//头插法
/*Lklist crea( )
{
Lklist h,s,p;
elemtype x;
h=(Lklist)malloc(sizeof(Lnode));
h-》next =NULL; p=h;
cout《《"创建单链表：";
cin》》x;
while(x!=-1)
{
s=(Lklist)malloc(sizeof(Lnode));
s-》data=x;
s-》next=h-》next;
h-》next=s;
cin》》x;
}
return h;
}*/
//尾插法
Lklist crea( )
{
Lklist h,s,p;
elemtype x;
h=(Lklist)malloc(sizeof(Lnode));
h-》next =NULL; p=h;
cout《《"创建单链表：";
cin》》x;
while(x!=-1)
{
s=(Lklist)malloc(sizeof(Lnode));
s-》data=x;
p-》next=s;
p=s;
cin》》x;
}
p-》next=NULL;
return h;
}
int lengthLklist(Lklist h)
{
Lklist p;
p=h;int j=0;
while(p-》next)
{
p=p-》next;
j++;
}
return j;
}
Lklist getLklist(Lklist h,int i)
{
Lklist p;
p=h;int j=0;
while(p-》next &&j《i)
{
p=p-》next ;
j++;
}
if(j==i) return p;
else return NULL;
}
void insertLklist(Lklist h,int i,elemtype x)
{
Lklist p;
Lklist s;
s=(Lklist)malloc(sizeof(Lnode));
s-》data =x;
p=getLklist(h,i-1);
s-》next =p-》next ;
p-》next =s;
}
void deleteLklist(Lklist &h,int i/*elemtype x */)
{
Lklist q;Lklist p;
p=h;int j=0;
while(p-》next &&j《i-1)
{
p=p-》next ;
++j;
}
if(!(p-》next ))
{
cout《《"删除位置不合理！";
return;
}
q=p-》next ;
p-》next=q-》next;
/*x=q-》data;*/
****(q);
}
void transLklist(Lklist &h)
{
Lklist p,q;
p=h-》next;
h-》next=NULL;
while(p)
{
q=p;
p=p-》next;
q-》next=h-》next;
h-》next=q;
}
}
void mergeLklist(Lklist &La,Lklist &Lb,Lklist &Lc)
{
Lklist pa,pb,pc;
pa=La-》next ;
pb=Lb-》next ;
Lc=pc=La;
while(pa&&pb)
{
if(pa-》data《=pb-》data)
{
pc-》next=pa;
pc=pa;
pa=pa-》next;
}
else
{
pc-》next=pb;
pc=pb;
pb=pb-》next;
}
}
pc-》next=pa?pa:pb;
****(Lb);
}
void print(Lklist h)
{
Lklist p;
p=h-》next;
while(p)
{
cout《《p-》data 《《" ";
p=p-》next ;
}
}
void main()
{
Lklist h,p,q;
int i,x;
h=crea( );
p=crea( );
q=(Lklist)malloc(sizeof(Lnode));
cout《《"原单链表1:";
print(h);
cout《《endl《《"原单链表2:";
print(p);
cout《《endl《《"单链表1长为："《《lengthLklist(h);
cout《《endl《《"输入要查找的元素位置i:";
cin》》i;
h=getLklist(h,i);
cout《《"查找后的单链表1:";
print(h);
cout《《endl《《"输入要插入的位置i和插入元素x:";
cin》》i》》x;
insertLklist(h,i,x);
cout《《"插入后的链表1:";
print(h);
cout《《endl《《"要删除的元素位置i:";
cin》》i;
deleteLklist(h,i);
cout《《"删除后的链表1:";
print(h);
cout《《endl《《"合并后的有序表:";
mergeLklist(h,p,q);
print(h);
transLklist(h);
cout《《endl《《"就地转置后的链表:";
print(h);
}

C语言链表操作

包括链表的创建删除添加和释放操作！！
#include《stdio.h》
#include《stdlib.h》
struct node *create();
void print_list(struct node *head);
struct node * insert_node(struct node *h,int x,int y);
struct node * delete_node(struct node *h,int z);
void shifang(struct node *head);
struct node
{
char data;
struct node *next;
};
void main()
{
struct node *head;
int x,y,z;
head=create();
print_list(head);
printf("\n输入插入结点的位置的值和插入的数值：");
scanf("%d%d",&x,&y);
head=insert_node(head,x,y);
print_list(head);
printf("\n输入要删除的结点：");
scanf("%d",&z);
head=delete_node(head,z);
print_list(head);
printf("\n释放链表.\n");
}
struct node *create() //建立链表函数
{
printf("请输入各节点（以-1结尾）：\n");
int x;
//定义指针*head，*tail，*s;
struct node *head,*tail,*s;
//head和tail初始化，生成一个头结点
head=tail=(struct node *)malloc(sizeof(struct node));
//在循环中，生成新结点、赋值、连接、尾指针后移
scanf("%d",&x);
while(x!=-1)
{
s=(struct node *)malloc(sizeof(struct node));
s-》data=x;
tail-》next=s;
tail=s;
scanf("%d",&x);
}
//尾结点的指针域赋NULL
tail-》next=NULL;
return head;
}
void print_list(struct node *head) //输出链表函数
{
//定义工作指针*p并赋初值p=head-》next；即指向第一个结点
struct node *p;
p=head-》next;
//判断链表是否为空，空：输出空表的信息，否则：输出所有结点
if(p==NULL)
printf("The list is NULL.");
else
//在循环中输出当前结点，工作指针后移
{
printf("head-》");
while(p!=NULL)
{
printf("%d-》",p-》data);
p=p-》next;
}
printf("end.");
}
}
struct node * insert_node(struct node *h,int x,int y) //添加结点函数
{
struct node *p,*q,*s;
//生成要插入的新结点
s=(struct node *)malloc(sizeof(struct node));
s-》data=y;
q=h;
p=h-》next;
//查找要插入结点的位置
while((p!=NULL)&&(p-》data!=x))
{
q=p;
p=p-》next;
}
//插入结点
q-》next=s;s-》next=p;
return(h);
}
struct node * delete_node(struct node *h,int z) //删除结点函数
{
struct node *p,*q;
q=h;
p=h-》next ;
//查找要删除结点的位置
if(p!=NULL)
{
while((p!=NULL)&&(p-》data!=z))
{
q=p;
p=p-》next;
}
//释放结点
if(p-》data ==z)
{
q-》next=p-》next ;
****(p);
}
}
return(h);
}
void shifang(struct node *head) //释放链表函数
{
struct node *p;
//逐个释放结点
while(head!=NULL)
{
p=head;
head=head-》next;
****(p);
}
}

C语言单向链表的创建，输入，插入和删除的实现

/* 线性表-链表的操作: 只提供核心语句 */
#include "stdio.h"
#include "stdlib.h"
#define N 100
typedef int ElemType;/* 链表的存储结构 */
typedef struct LNode{
ElemType data;
struct LNode *next; } LNode,*LinkList;/* 链表的基本操作 *//******* 1.初始化链表 ******/
void InitList(LinkList *L)
{ *L=(LinkList)malloc(sizeof(LNode));
(*L)-》next=NULL; }/******* 2.销毁链表 ******/
void DestroyList(LinkList *L)
{ LinkList p;
while(*L!=NULL)
{ p=*L;
*L=(*L)-》next;
****(p); }
}
/******* 10.在顺序表第n个位置插入元素e ******/
void ListInsert(LinkList *L, int n, ElemType e)
{ LinkList p,q,new; int i;
q=*L; p=(*L)-》next; i=1;
while (p!=NULL && i《n) { q=p; p=p-》next; i++; }
new=(LinkList)malloc(sizeof(LNode));
new-》data=e;
q-》next=new; new-》next=p; }/******* 11.删除链表中第n个位置的元素 ******/
void ListDelete(LinkList *L, int n, ElemType *e)
{ LinkList p,q; int i;
q=*L; p=(*L)-》next; i=1;
while (p!=NULL && i《n) { q=p; p=p-》next; i++; }
*e=p-》data;
q-》next=p-》next; ****(p); }/******* 12.遍历链表并输出 ******/
void ListTraverse(LinkList L)
{ LinkList p;
printf("\nList:\t");
p=L-》next;
while (p!=NULL)
{ printf("%d\t",p-》data);
p=p-》next; }
}/******* A(2).后接法建立顺序链表 ******/
void CreateList2(LinkList *L, ElemType a, int n)
{ LinkList p,new; int i;
p=*L;
for(i=0; i《n; i++)
{ new=(LinkList)malloc(sizeof(LNode));
new-》data=a;
p-》next=new; p=p-》next; }
p-》next=NULL;
}
/* 主函数 */
main()
{ LinkList La; ElemType a={1,3,5,7,9},x;
InitList(&La);//初始化链表
CreateList2(&La,a,5);//建立链表并用数组赋值
ListTraverse(La);//遍历链表
ListInsert(&La, 3, 100);//第三个位置插入100
ListTraverse(La);//遍历链表
ListDelete(&La,5,&x);//删除第五个元素,用x返回
ListTraverse(La);//遍历链表 DestroyList(&La);//销毁链表
} 这是我们刚学的，保证简洁准确

链表基本操作练习（C语言）

说真的,你的分数太少了.当我弄了一半的时候才觉得有点不值,但又不想半途而废,最终还是帮你做了,所以希望你能及时采纳,这可是我弄了好久的呀!
好了,最后还帮你修改了一遍,已经编译通过的了.并且检查过可以完成你说的功能的了.
#include《stdlib.h》
#include《stdio.h》
typedef struct list
{
int num;struct lst *next;
} LST;
LST *mycreat()
{
int data=0;
LST *head=NULL,*p=NULL,*q=NULL;
head=(LST*)malloc(sizeof(LST));
q=head;
printf("请输入链表数据(整型)并以空格空开,以-1为最后一个数,回车结尾:\n");
scanf("%d",&data);
while(data!=-1)
{
p=(LST*)malloc(sizeof(LST));
q-》next=p;
p-》num=data;
q=p;
scanf("%d",&data);
}
q-》next=NULL;
return head;
}
void mycheck(LST *head)
{
int i=0,x=0;
LST *p=NULL;
printf("\n请输入要查询的结点:\n");
scanf("%d",&x);
p=head;
while(p!=NULL)
if(i!=x)
{
p=p-》next;
i++;
}
else break;
if(p!=NULL)printf("\nthe %d node is %d\n",x,p-》num);
else printf("\n there is no this node\n");
}
int mydelete (LST* head,int m)
{
LST *p=NULL,*q=NULL;
q=head;
p=head-》next;
while(p!=NULL)
if(m!=p-》num)
{
q=q-》next;
p=p-》next;
}
else break;
if(p==NULL) return 0;
q-》next=p-》next;
****(p);
return 1;
}
void myprint(LST *head)
{
LST *p=NULL;
p=head-》next;
if(p==NULL)printf("\n empty list!");
else
do
{
printf("\n%5d\n",p-》num);
p=p-》next;
}while(p!=NULL);
printf("\n");
}
int thelength(LST *head)
{
int length=0;
LST *p=NULL;
p=head;
while(p!=NULL)
{
p=p-》next;
length++;
}
return length;
}
void clear(LST *head)
{
LST *p=NULL;
p=head;
while(p-》next!=NULL)
{
p=p-》next;
p-》num=0;
}
}
main()
{
int k=0,m=0,l=0;
LST *head=NULL;
head=mycreat();
mycheck(head);
printf("to delete list:");
scanf("%d",&m);
k=mydelete(head,m);
if(k==1)
{
printf("after deleting");
myprint(head);
}
else printf("not exist.\n");
l=thelength(head);
printf("the length is %d",l);
clear(head);
}