线性表顺序存储用c语言写
‘壹’ 是c语言中建立顺序表的程序
C语言中建立顺序表的操作顺序如下：
1.清空顺序表：其实清空只不过将元素长度置0，让后面插入数据函数的长度从0开始，其实并不是真正清空，之前的数据元素在内存中还存在，只不过可以被新元素覆盖而已。
2.判断顺序表是否为空
‘贰’ 用C语言给出线性表的顺序存储结构的类型定义
这很简单的问题啊...
#define
maxsize
100
typedef
char
elemtype
typedef
struct
{
elemtype
data[maxsize];
//存放顺序表元素
int
length;
//存放顺序表的长度
};
//顺序表的类型定义
‘叁’ 利用c语言实现顺序存储线性表的插入!
有时会出现这种情况。他会以为是木马。
int GetElem();
int InstInsert();
typedef int ElemType;
typedef struct{
ElemType *elem; //存储空间基地址
int length; //当前长度
int listsize;//当前分配的存储容量
}sqlist;
int InitList(SqList *L){
L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L->elem)exit(-1);//存储空间分配失败
L->length=0; //空表长度为0
L->listsize=LIST_INIT_SIZE; //初始存储容量
printf("线性链表创建成功\n");
return OK;
}
int Input(SqList *L){
ElemType temp,*newbase;
printf("输入顺序列表的数据，以0为结束标志\n");
scanf("%d",&temp);
while(temp!=0){
if(L->length>=L->listsize){
newbase=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!newbase) exit(-1);//存储空间分配失败
L->elem=newbase; //空间新基地址
L->listsize+=LISTINCREMENT; //增加存储容量
}
L->elem[L->length++]=temp;
scanf("%d",&temp);
}
printf("输入数据结束！！\n");
return OK;
}
int Onput(SqList *L){
int i=0;
printf("输出线性表数据：");
while(i<L->length){
printf("%d\t",L->elem[i]);
i++;
}
printf("\n");
}
int ClearList(SqList *L){
L->length=0;
printf("清除成功!\n");
return OK;
}
void ListEmpty(SqList L){
if(L.elem!=NULL)
printf("true!\n");
else
printf("false!\n");
}
void ListLength(SqList L){
printf("线性表的长度是：%d\n",L.length);
return ;
}
int GetElem(SqList L,int i,SqList *e){
e=L.elem[i-1];
return e;
}
void PriorElem(SqList L,int cur_e,SqList *pre_e){
if(cur_e!=L.elem[0]){
pre_e=L.elem[0];
printf("前驱值为：%d\n",pre_e);
}
else
printf("pre_e无意义\n");
}
void NextElem(SqList L,int cur_e,SqList *next_e){
if(cur_e!=L.elem[L.length-1]){
next_e=L.elem[L.length-1];
printf("后继值为：%d\n",next_e);
}
else
printf("next_e无意义\n");
}
int ListInsert(SqList *L,int i,int e){
ElemType *newbase,*p,*q;
if(1>i||i>(L->length+1))
return -1;
if(L->length>=L->listsize){ //新增内存
newbase=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); //开辟新内存空间
if(!newbase)
exit(-1); //存储分配失败
L->elem=newbase; //新基地址
L->listsize+=LISTINCREMENT; //新增内存容量
}
q=&(L->elem[i-1]);
for(p=&(L->elem[L->length-1]);p>=q;p--){
*(p+1)=*p;
}
*q=e;
++L->length;
return OK;
}
int ListDelete(SqList *L,int i,int e){
ElemType *p,*q;
if(i<1||i>L->length)
return -1;
q=&(L->elem[i-1]);
e=L->elem[i-1];
p=L->elem+L->length-1;
for(;p>=q;q++)
*q=*(q+1);
--L->length;
printf("删除的值为：%d\n",e);
return OK;
}
‘肆’ 用C语言实现线性表的顺序存储（创建，插入，删除和查找）
//C++课程设计---学生成绩管理系统
#include <stdio.h>
#include <string.h>
#include <iostream.h>
#include <stdlib.h>
#include <windows.h>
typedef struct studentinfo //结构体定义
{
int num;//学号
char name[64];//姓名
int sex;//性别，1为男性，0为女性
float math;//数学
float english;//英语
float politic;//政治
float chinese;//语文
float total;//总成绩
struct studentinfo *next;
}STUDENT;
#define FILENAME "D:\\1.txt"
//定义默认的数据库文件
#define DELAYTIME 1500
//显示信息，延时
void create_menu();
STUDENT * new_student();
STUDENT* create_linkbyfile(char *);
STUDENT *del_info(STUDENT *);
int save_info(char *,STUDENT *,int);
int find_infile_printf(char *);
int pri_whole_link(STUDENT *);
STUDENT* printf_sort(STUDENT *);
void free_link(STUDENT *);
void main() //主函数
{
create_menu();
}
STUDENT * reverse(STUDENT *head)
//功能：链表反转顺序
//参数：head链表头结点指针
{
STUDENT *ptemp,*p1;
if(head==NULL)
{
return 0;
}
p1=head;//p1使之永远指向排好序的第一个结点，初值为head，head使之永远是已经排好序的最后一个结点
while(head->next!=NULL)//本次循环使ptemp排好序
{
ptemp=head->next;//ptemp指向未排好序的第一个结点
head->next=ptemp->next;//
ptemp->next=p1;//ptemp也排好序了，ptemp变成排好序的第一个结点了
p1=ptemp;//再次让p1成为第一个排好序的结点
}
return p1;//头结点为第一个结点
}
void create_menu()
//功能：输出功能菜单，提供人-机接口
{
char menu_Num;
STUDENT *head=NULL;
char ch;
char file_name[256];
while(1)
{
system("cls");
cout<<"\t\t学生成绩管理系统\n";
cout<<"##########################################\n";
cout<<"#\t\t 1.新增学生信息\t\t #\n";
cout<<"#\t\t 2.加载数据库\t\t #\n";
cout<<"#\t\t 3.删除学生信息\t\t #\n";
cout<<"#\t\t 4.保存学生信息\t\t #\n";
cout<<"#\t\t 5.数据库查询\t\t #\n";
cout<<"#\t\t 6.原序输出\t\t #\n";
cout<<"#\t\t 7.排序输出\t\t #\n";
cout<<"#\t\t 8.退出\t\t\t #\n";
cout<<"##########################################\n";
cout<<"请输入操作编号：";
cin>>menu_Num;
switch (menu_Num)
{
case '1':
free_link(head);//释放链表空间
head=new_student();//新增学生信息
break;
case '2':
free_link(head);//释放链表空间
cout<<"请输入要加载的数据库文件的路径"<<endl;
cin>>file_name;
head=create_linkbyfile(file_name);//读取数据文件
if(head!=NULL)
{
cout<<"数据库"<<file_name<<"已加载"<<endl;
Sleep(DELAYTIME);
}
break;
case '3':
del_info(head);//删除学生信息
break;
case '4'://保存学生信息
if (head==NULL)
{
cout<<"请先生成学生信息"<<endl;
Sleep(DELAYTIME);
}
else
{
cout<<"想将学生信息保存到哪个数据库文件？";
cin>>file_name;
cout<<"请选择保存方式：0追加到文件末尾 1覆盖文件\n";
cin>>menu_Num;
if(save_info(file_name,head,menu_Num-'0')==0)//0表示追加，1表示覆盖
{
cout<<"信息保存失败\n";
}
else
{
cout<<"数据已保存到"<<file_name<<endl;
Sleep(DELAYTIME);
}
}
break;
case '5':
find_infile_printf(FILENAME);//数据库查询
break;
case '6'://原序输出信息
pri_whole_link(head);
cout<<"返回主菜单？ Y/N\t";
do
{
cin>>ch;
}while(ch!='Y'&&ch!='y');
break;
case '7'://排序输出信息
do
{
if((head=printf_sort(head))==NULL)
{
cout<<"数据库未加载"<<endl;
Sleep(DELAYTIME);
break;
}
else
{
cout<<"选择其他方式排序？ Y/N\t";
cin>>ch;
}
}while(ch=='Y'||ch=='y');
break;
case '8':
free_link(head);//释放链表空间
exit(0);
break;
default:
cout<<"输入有误！请重新输入！"<<endl;
Sleep(DELAYTIME);
break;
}
}
}
STUDENT * new_student()
//功能：创建学生信息（通过链表）
//返回值：头结点指针
{
STUDENT *pnew,*p,*head;
float *pfloat;
char ch;
head=NULL;
do
{
system("cls");
pnew=(STUDENT *)malloc(sizeof(STUDENT)*1);
cout<<"请输入学生的学号(0表示取消)： ";
cin>>pnew->num;
if(0>=pnew->num)
{
break;
}
cout<<"请输入学生的姓名：";
cin>>pnew->name;
while(1)
{
cout<<"请输入学生的性别：0/1\t";
cin>>pnew->sex;
if(pnew->sex&&pnew->sex-1)
{
cout<<"性别输入错误，0表示女性，1表示男性，请重新输入"<<endl;
}
else
{
break;
}
}
cout<<"请依次输入学生的数学、英语、政治、语文成绩："<<endl;
for(pnew->total=0,pfloat=&pnew->math;pfloat<&pnew->math+4;)
{
cin>>*pfloat;
if(*pfloat<0||*pfloat>150)
{
cout<<"成绩输入错误，只能为0~150"<<endl;
}
else
{
pnew->total+=*pfloat;
pfloat++;
}
}
if(head==NULL)
{
head=pnew;
}
else
{
p->next=pnew;
}
p=pnew;
pnew->next=NULL;
cout<<"##########################该学生信息已生成#########################\n";
cout<<"建立另一个学生的信息？ Y/N\t";
cin>>ch;
}while(ch=='Y'||ch=='y');
return head;
}
STUDENT* create_linkbyfile(char *filename)
//功能：读取文件，创建链表
//参数：如果filename不为空，则打开该文件，如果filename为空，要求输入文件位置
//创建的链表的所有结点的next全部修改，指向物理地址上的下一个结点
{
system("cls");
FILE *fp;
STUDENT *head,*ptemp,*pnew;
head=NULL;//初始化head为空
if(filename==NULL)//若filename为空，要求输入文件绝对地址
{
char file_name[256];
cout<<"请输入数据库文件的路径："<<endl;
cin>>file_name;
if(NULL==(fp=fopen(file_name,"rb")))
{
cout<<"数据库连接失败\n";
return 0;
}
}
else
{
if(NULL==(fp=fopen(filename,"rb")))
{
cout<<"数据库连接失败\n";
return 0;
}
}
for(ptemp=NULL;;)
{
pnew=(STUDENT *)malloc(sizeof(STUDENT)*1);
if(fread(pnew,sizeof(STUDENT),1,fp)!=NULL)
{
if(ptemp!=NULL)
{
ptemp->next=pnew;
}
else
{
head=pnew;
}
ptemp=pnew;
}
else
{
if(ptemp!=NULL)
{
ptemp->next=NULL;
}
else
{
head=NULL;
}
free(pnew);
break;
}
}
fclose(fp);
return head;
}
STUDENT *del_info(STUDENT *head)
//根据学号，删除链表的结点
{
system("cls");
STUDENT *p1,*p2;
int num;
if (head==NULL)
{
cout<<"数据库未加载"<<endl;
Sleep(DELAYTIME);
return 0;
}
cout<<"请输入要删除学生的学号：";
cin>>num;
for(p1=head;p1!=NULL;)
{
if(p1->num==num)//找到
{
if(p1==head)//要删除的结点是头结点
{
head=p1->next;
}
else
{
p2->next=p1->next;
}
cout<<"成功删除！！";
}
p2=p1;
p1=p1->next;
}
return head;
}
int save_info(char *filename,STUDENT *head,int flag)
//功能：将链表按Binary写入文件末尾
//参数：
//1.filename文件名，绝对地址
//2.head指向链表的头结点
//3.flag 0追加或1覆盖数据
//返回值：失败则返回0
{
system("cls");
FILE *fp;
STUDENT *p;
char openmethod[8];
if(flag==0)
{
strcpy(openmethod,"ab+");//追加
}
else
{
strcpy(openmethod,"w");//覆盖
}
if(NULL==(fp=fopen(filename,openmethod)))//
{
cout<<"数据库连接失败"<<endl;
Sleep(DELAYTIME);
return 0;
}
else
{
for(p=head;p;p=p->next)
{
if((fwrite(p,sizeof(STUDENT),1,fp))==NULL)
{
cout<<"数据库创建失败"<<endl;
return 0;
}
}
}
fclose(fp);
return 1;
}
int find_infile_printf(char *filename)
//功能：根据学号和姓名来查询某个学生
//参数：filename数据库文件
//返回值：失败返回0
//直接搜索文件，缺点是速度慢
//也可先根据文件创建链表，再搜索链表，缺点是如果文件较大，占用内存多
{
system("cls");
FILE *fp;
STUDENT stu;
int num;
char stu_name[64];
char ch;
if(filename==NULL)
{
return 0;
}
do
{
memset(stu_name,0,sizeof(stu_name));
cout<<"查询学号或查询姓名？ 1查询学号 0查询姓名";
//flag=1根据学号来查询，flag=0根据姓名来查询
cin>>num;
if(num==1)
{
cout<<"输入要查询的学号：";
cin>>num;
cout<<"正在为您查询学号为"<<num<<"的学生……"<<endl;
}
else if(num==0)
{
cout<<"输入要查询的姓名：";
cin>>stu_name;
cout<<"正在为您查询姓名为"<<stu_name<<"的学生……"<<endl;
}
else
{
cout<<"输入有误"<<endl;
return 0;
}
if(NULL==(fp=fopen(filename,"rw")))
{
cout<<"数据库连接失败\n";
return 0;
}
else
{
while(fread(&stu,sizeof(STUDENT),1,fp)!=NULL)
{
if(strcmp(stu.name,stu_name)==0||stu.num==num)
{
cout<<"学号\t姓名\t性别\t数学\t英语\t政治\t语文\t总成绩\n";
//输出该学生的所有信息
cout<<stu.num<<"\t"<<stu.name<<"\t"<<stu.sex<<"\t"<<stu.math<<"\t"<<stu.english<<"\t"<<stu.politic<<"\t"<<stu.chinese<<"\t"<<stu.total<<endl;
//不加break;可支持多个相同数据的索引
}
}
}
cout<<"##########################查询完毕#########################\n";
cout<<"查询另一个学生的信息？ Y/N\t";
cin>>ch;
}while(ch=='Y'||ch=='y');
fclose(fp);
return 1;
}
int pri_whole_link(STUDENT *head)
//功能：显示整条链表的学生信息
//参数：head 头结点指针，如果head为空，返回空
{
system("cls");
STUDENT* p;
if (head==NULL)
{
cout<<"数据库未加载"<<endl;
Sleep(DELAYTIME);
return 0;
}
cout<<"学号\t姓名\t性别\t数学\t英语\t政治\t语文\t总成绩\n";
for(p=head;p;p=p->next)
{
cout<<p->num<<"\t"<<p->name<<"\t"<<p->sex<<"\t"<<p->math<<"\t"<<p->english<<"\t"<<p->politic<<"\t"<<p->chinese<<"\t"<<p->total<<endl;
}
return 1;
}
STUDENT* printf_sort(STUDENT *head)
//功能：根据学号|某科目成绩|总成绩对链表进行排序，然后输出
//参数：head链表头指针，如果head为空，返回空
//返回值：返回新的链表的头结点指针
{
system("cls");
STUDENT *p1,*p2,*ptemp,*pfinished=NULL;
char num;
char flag;
if (head==NULL)
{
return 0;
}
cout<<"选择排序依据 0.数学成绩1.英语成绩2.政治成绩3.语文成绩4.总成绩\n";
while(1)
{
cin>>num;
if(num>'4'||num<'0')
{
cout<<"输入有误，请重新输入 0~4"<<endl;
}
else
{
break;
}
}
cout<<"升序/降序输出？ 0.降序1.升序";
while(1)
{
cin>>flag;
if(flag>'1'||flag<'0')
{
cout<<"输入有误，请重新输入 0~1"<<endl;
}
else
{
break;
}
}
for(p1=head;p1->next!=pfinished;)//对链表进行从大到小排序（这里用冒泡法）
//p1使之总是指向头结点，pfinished使之总是指向已排序好的最前面的结点
//ptemp作为中介，保存p2的上一个结点
{
for(p2=p1;p2->next!=pfinished;)
{
if(*(&(p2->math)+num-'0')<*(&(p2->next->math)+num-'0'))//p2的值小于p2->next的值，交换 ptemp p2 p2->next
{
if(p2==p1)//头结点要交换
{
p1=p2->next;
p2->next=p1->next;
p1->next=p2;
ptemp=p1;
}
else
{
ptemp->next=p2->next;
ptemp=p2->next;
p2->next=ptemp->next;
ptemp->next=p2;
}
}
else//不需要交换，则p2、ptemp前进1位
{
ptemp=p2;
p2=p2->next;
}
}
pfinished=p2;
}
if(flag=='1')
{
p1=reverse(p1);
}
pri_whole_link(p1);
cout<<"##########################信息显示完毕#########################\n";
return p1;
}
void free_link(STUDENT *head)
//释放链表空间，如果head，什么都不做
{
STUDENT *p1,*p2;
for(p1=head;p1;p1=p2)
{
p2=p1->next;//先保存,否则
free(p1);//free后 p1->next数据丢失
}
}
‘伍’ 用c语言描述顺序存储结构的线性表求表长的算法
#include<stdio.h>
#include<stdlib.h>
#define list_init_size 5
#define listincrement 10
#define overflow -2
typedef int status;
typedef int elemtype;
typedef struct
{
elemtype *elem;
int length;
int listsize;
} sqlist;
status initlist_sq(sqlist &L)
{
L.elem=(elemtype *)malloc(list_init_size * sizeof(elemtype));
if(!L.elem) exit(overflow);
L.length=0;
L.listsize=list_init_size;
return 1;
}
将顺序表初始化为5个元素,在结构中定义了顺序表的长度,int length:所以在主函数中可以直接调用用printf("%d",L.length)就得到了当前的长度,无论是删除,添加,L.length都会随着改变,比如我们建一个添加的函数
status listinsert_sq(sqlist &L, int i ,elemtype e)
{
int * q , *p ,* newbase;
if(i<1 || i>L.length + 1) return 0;
if(L.length >= L.listsize)
{
newbase=(elemtype *)realloc(L.elem,(L.listsize+listincrement) * sizeof(elemtype));
if(!newbase) exit (overflow);
L.elem=newbase;
L.listsize+=listincrement;
}
q=&(L.elem[i-1]);
for(p=&(L.elem[L.length-1]) ;p>=q ;--p)
*(p+1) = *p;
*q = e;
++L.length;
return 1;
}
如果加一个元素,就会把L.length自动加1,这样避免了再写函数求表长
‘陆’ 用C语言建立一个顺序存储的线性表并实现线性表的插入和删除操作
链表
1。是由结构体和指针构成的。
2。包括两个部分一个是数据域和指针域。
3。链表中的结点分为两类：头结点和一般结点。头结点是没有数据域的。
4。基本操作有：初始化链表，增加结点和删除结点，求链表的长度等等。
struct Linknode{
int data;
struct Linknode *next;
};
这个地方有个知识点：这个是链表的数据结构是有结构体和指针构成。结构体名为Linknode.但这里面没有定义结构体变量，只有我们定义了结构体变量才能使用结构体。
结构体变量怎么定义呢？
有两种方式：
1。struct Linknode Linklist;
2.typedef struct linknode Linklist.
一般我们都希望采用第2种，这样的好处是: 当我们再定义结构体变量时，可以用：Linklist p;而如果我们采用第一种还必须采用 struct Linknode p;对比一下就可以知道第2种要简单很多。那么下面我们都采用第2种方式来定义结构体变量。
上面我们已经定义了一个链表：
1。初始化链表。
#include
#include
int InitLinkList(Linklist **Lnode)
{
*Lnode=(Linklist)malloc(sizeof(Linklist));//*Lnode等于L，对与*Lnode的分配空间相当与对主函数中的L分配空间。
if(!*Lnode)
return 0;
（*Lnode）->next=NULL;
}
在初始化链表的时候，我们用到了2级指针为什么呢？因为我们希望在InitLinkList函数生成的头结点，主函数中也能指向这个头结点。如果我们用一级指针的话，用malloc分配空间的时候，它将会返回分配空间的首地址给指针变量Lnode，而不能使是的空间被主函数中指针变量L得到这个地址。所以我们要用2级指针。
void main()
{
Linklist *L;
InitLikList(&L);
}
2。增加链表结点
增加链表结点其实很简单，一般用到三个结构体指针变量和一个循环结构。
InsertLinkList(Linklist *Lnode)
{
Linklist *p,*q;
int d;
{
scanf("%d",&d);
if(d==-9999)
break;
p=Lnode->next;//p指向头结点
//通过while循环和指针变量p定位要插入的结点q的位置。
while（p）
p=p->next;
//生成一个要插入的结点
q=(Linklist)malloc(sizeof(Linklist));//申请要插入的结点空间
q->data=d;//填充要插入结点的数据域
q->next=p->next;//首先填充要插入结点q的指针域进行填充。
p->next=q;//然后把定位好的p指针域进行修改指向q.
}while(9);//循环退出的条件是输入的数据-9999
}
void main()
{
Linklist *L;
InitLinkList(&L);//生成一个头结点
InsertLinkList(L);//插入结点
}
3。求链表的长度：
int LengthLinkList(Linklist *Lnode)
{
int i=0;
Linklist *p;
p=Lnode->next;//p指向链表的第一个结点。
while(p)
{
i++;
p=p->next;
}
return i;
}
void main()
{
Linklist *L;
InitLinkList(&L);//生成一个头结点
InsertLinkList(L);//插入一个结点
LengthLinkList(L)//求链表的长度。
}
4.删除结点
删除链表结点其实很简单，一般用到三个结构体指针变量和一个循环结构。
DestroyLinkList(Linklist *Lnode)
{
Linklist *p,*q;
p=Lnode;//p指向链表的头结点
while(p)
{
q=p->next;//q指向当前结点的下一个结点。
free(p);//释放当前结点
p=q;//p指向下一个结点
}
}
void main()
{
Linklist *L;
InitLinkList(&L);//生成一个头结点
InsertLinkList(L);//插入结点
LengthLinkList(L)//求链表的长度。
DestroyLinkList(L);//删除链表结点
}
‘柒’ 利用线性表的顺序存储结构完成一个班级的所有课程的管理c语言要求实现增加，删除，修改学生成绩记录等功
#include <stdio.h>
#include <stdlib.h>
typedef struct LNode{
int data; //链表数据
struct LNode* next; //链表指针
}LNode,*LinkList;
/*头插法-建立单链表*/
LinkList HeadCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode)); //建立头结点
la->next=NULL;
scanf("%d",&num);
while(num!=10)
{
LNode *p=(LinkList)malloc(sizeof(LNode));
p->data=num;
p->next=la->next;
la->next=p;
scanf("%d",&num);
}
return la;
}
/*尾插法-建立单链表*/
LinkList TailCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode));
la->next=NULL;
LinkList s,r=la;
scanf("%d",&num);
while(num!=10)
{
s=(LinkList)malloc(sizeof(LNode));
s->data=num;
r->next=s;
r=s;
scanf("%d",num);
}
r->next=NULL;
return la;
}
/*单链表遍历*/
void TravelList(LinkList la)
{
LinkList p=la->next;
while(p!=NULL)
{
printf("%d->",p->data);
p=p->next;
}
printf("\n");
}
/*单链表的按位查找*/
LinkList GetElem(LinkList la,int i)
{
int j=1;
LNode* p=la->next;
if(i<1)
return NULL;
while(p && j<i)
{
p=p->next;
j++;
}
return p;
}
/*单链表的按值查找*/
LinkList LocalElem(LinkList la,int e)
{
LNode* p=la->next;
while(p!=NULL && p->data!=e)
p=p->next;
return p;
}
/*单链表插入操作*/
bool InsertList(LinkList la,int i,int e)
{
//在la链表中的i位置插入数值e
int j=1;
LinkList p=la,s;
while(p && j<i)
{
p=p->next;
j++;
}
if(p==NULL)
return false;
if((s=(LinkList)malloc(sizeof(LNode)))==NULL)
return false;
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
/*单链表删除操作*/
bool DeleteList(LinkList la,int i)
{
int j=1;
LinkList p=la,q;
while(p && j<i) //p指向第i-1个元素
{
p=p->next;
j++;
}
if(p==NULL || p->next==NULL) //表示不存在第i-1个和第i的元素
return false;
q=p->next;
p->next=q->next;
free(q);
return true;
}
/*单链表的表长*/
int LengthList(LinkList la)
{
int nLen=0;
LinkList p=la->next;
while(p)
{
p=p->next;
nLen++;
}
return nLen;
}
/*单链表逆置*/
LinkList Reserve(LinkList la)
{
if(la==NULL || la->next==NULL)
return la;
LinkList p=la->next,q=p->next,r=q->next;
la->next=NULL;
p->next=NULL;
while(r!=NULL)
{
q->next=p;
p=q;
q=r;
r=r->next;
}
q->next=p;
la->next=q;
return la;
}
int main()
{
LNode la;
LinkList p;
p=HeadCreate(&la); //头插法创建单链表
TravelList(p);
printf("%p\n",GetElem(p,1)); //获得第1个结点地址
InsertList(p,2,10); //在链表的第2个位置插入元素10
TravelList(p);
DeleteList(p,3); //删除链表的第3个元素
TravelList(p);
printf("%d\n",LengthList(p)); //获得链表长度
p=Reserve(p);
TravelList(p);
return 0;
}
//运行结果
//5 6 12 7 8 14 9 3 2 5 14 10 头插法创建链表
//14->5->2->3->9->14->8->7->12->6->5-> 显示链表
//00382490 第一个结点的地址
//14->10->5->2->3->9->14->8->7->12->6->5-> 插入元素值为10的结点
//14->10->2->3->9->14->8->7->12->6->5-> 删除第三个结点
//11 获得链表长度
//5->6->12->7->8->14->9->3->2->10->14-> 链表逆置
//Press any key to continue
这是我写的一个线性表链式存储的综合程序，包含了你所要的创建、删除、插入、按值查找的功能，还有一些额外的功能。下面加注释的是程序运行结果，你可以参考试着改改程序，让程序更加完美。希望对你有帮助，呵呵！