线性表顺序存储及实现

⑴ 用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>
//以下为函数运行结果状态代码
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
#defineLIST_INIT_SIZE100//线性表存储空间的初始分配量
#defineLISTINCREMENT10//线性表存储空间分配增量
typedefintStatus;//函数类型，其值为为函数结果状态代码
typedefintElemType;//假设数据元素为整型
typedefstruct
{
ElemType*elem;//存毕碰储空间基址
intlength;//当前长度
intlistsize;//当前分配的存储容量
}sqlist;
//实现线性表的顺序存储结嫌誉构的类型定义
//函数声明开手者谈始
StatusInitList_Sq(SqList&L);
voidDestroyList_Sq(SqList&L);
voidClearList_Sq(SqList&L);
voidListEmpty_Sq(SqListL);
StatusGetElem_Sq(SqListL,i,&e);
intLocateElem_Sq(SqListL,e,compare());
StatusPriorElem_Sq(SqListL,cur_e,&pre_e);
StatusNextElem_Sq(SqListL,cur_e,&next_e);
StatusListInsert_Sq(SqList&L,i,e);
StatusListDelete_Sq(SqList&L,i,&e);
ListTravel_Sq(SqListL,visit());
//函数声明结束
intmain(void)
{
return0;
}
//函数定义开始
///////////////////////////////////////
//函数名：InitList_Sq()
//参数：SqList*L
//初始条件：无
//功能：构造一个空线性表
//返回值：存储分配失败：OVERFLOW
//存储分配成功：OK
///////////////////////////////////////
StatusInitList_Sq(SqList*L)
{
L.elem=(ElemType*)malloc((LIST_INIT_SIZE*sizeof(ElemType));//分配空间
if(!L.elem)
exit(OVERFLOW);//若存储分配失败，返回OVERFLOW
L.length=0;//空表，长度为0
L.listsize=LIST_INIT_SIZE;//初始存储容量
returnOK;
}
///////////////////////////////////////
//函数名：DestroyList_Sq()
//参数：SqList*L
//初始条件：线性表L已存在
//功能：销毁线性表
//返回值：无
///////////////////////////////////////
voidDestroyList_Sq(SqList*L)
{
if(L->elem)
free(L->elem);//释放线性表占据的所有存储空间
}
///////////////////////////////////////
//函数名：ClearList_Sq()
//参数：SqList*L
//初始条件：线性表L已存在
//功能：清空线性表
//返回值：无
///////////////////////////////////////
voidClearList_Sq(SqList*L)
{
L->length=0;//将线性表的长度置为0
}
///////////////////////////////////////
//函数名：ListEmpty_Sq()
//参数：SqListL
//初始条件：线性表L已存在
//功能：判断线性表是否为空
//返回值：空：TRUE
//非空：FALSE
///////////////////////////////////////
StatusListEmpty_Sq(SqListL)
{
if(L.length==0)
returnTRUE;
else
returnFALSE;
}
///////////////////////////////////////
//函数名：ListLength_Sq()
//参数：SqListL
//初始条件：线性表L已存在
//功能：返回线性表长度
//返回值：线性表长度(L.length)
///////////////////////////////////////
StatusListLength_Sq(SqListL)
{
return(L.length);
}
///////////////////////////////////////
//函数名：GetElem_Sq()
//参数：SqListL,inti,ElemType*e
//初始条件：线性表L已存在，1<=i<=ListLength(L)
//功能：用e返回线性表中第i个元素的值
//返回值：(i<1)||(i>ListLength(L))：ERROR
//1<=i<=ListLength(L)：OK
///////////////////////////////////////
StatusGetElem_Sq(SqListL,inti,ElemType*e)
{
if(i<1||i>L.length)
returnERROR;//判断i值是否合理，若不合理，返回ERROR
*e=L.elem[i-1];//数组中第i-1的单元存储着线性表中第i个数据元素的内容
returnOK;
}
///////////////////////////////////////
//函数名：LocateElem_Sq()
//参数：L,e,compare(ElemType1,ElemType2)
//初始条件：线性表L已存在，compare()为数据元素判定函数
//功能：返回顺序表L中第1个与e满足关系compare()的数据元素的位序
//返回值：若在L中存在于e满足关系compare()的元素：其位序
//若在L中不存在于e满足关系compare()的元素：0
///////////////////////////////////////
intLocateElem_Sq(SqListL,e,compare(ElemType1,ElemType2))
{
inti=1;//i的初值为第1元素的位序
intp=L.elem;//p的初值为第1元素的存储位置
while(i<=L.length&&!(*compare)(*p++,e))
++i;//依次进行判定
if(i<=L.length)
returni;//找到满足判定条件的数据元素为第i个元素
else
return0;//该线性表中不存在满足判定的数据元素
}
StatusPriorElem_Sq(SqListL,cur_e,&pre_e);
//见StatusNextElem_Sq(SqListL,cur_e,&next_e);
StatusNextElem_Sq(SqListL,cur_e,&next_e);
//我的思路是先用LocateElem_Sq()搜索cur_e的位序，
//再看是否大于等于length，
//若是，则返回OVERFLOW；否则返回后继
//这样也许有点麻烦？所以希望大家能够补充方案
//bywangweinoo1
///////////////////////////////////////
//函数名：ListInsert_Sq()
//参数：SqList*L,inti,ElemTypee
//初始条件：线性表L已存在，1<=i<=ListLength(L)+1
//功能：在线性表中第i个数据元素之前插入数据元素e
//返回值：失败：ERROR
//成功：OK
///////////////////////////////////////
StatusListInsert_Sq(SqList*L,inti,ElemTypee)
{
ElemType*j;
if(L->length==LIST_MAX_LENGTH)
returnERROR;//检查是否有剩余空间
if(i<1||i>L->length+1)
returnERROR;//检查i值是否合理
//将线性表第i个元素之后的所有元素向后移动
for(j=L->length-1;j>=i-1;i++)
L->elem[j+1]=L->elem[j];
L->elem[i-1]=e;//将新元素的内容放入线性表的第i个位置，
L->length++;
returnOK;
}
///////////////////////////////////////
//函数名：ListDelete_Sq()
//参数：SqList*L,inti,Elemtype*e
//初始条件：线性表L已存在，1<=i<=ListLength(L)
//功能：将线性表L中第i个数据元素删除
//返回值：失败：ERROR
//成功：OK
///////////////////////////////////////
intListDelete_Sq(SqList*L,inti,Elemtype*e)
{
if(IsEmpty(L))
returnERROR;//检测线性表是否为空
if(i<1||i>L->length)
returnERROR;//检查i值是否合理
*e=L->elem[i-1];//将欲删除的数据元素内容保留在e所指示的存储单元中
//将线性表第i+1个元素之后的所有元素向前移动
for(j=i;j<=L->length-1;j++)L->elem[j-1]=L->elem[j];
L->length--;
returnOK;
}
//函数定义结束

⑶ 线性表的顺序存储结构用C++实现

线性表的顺序存储结构用C++实现代码：

#include "pch.h"

#include <stdio.h>

#include <malloc.h>

//#define DATA int

typedef int DATA;

struct SNode

{

DATA data;

SNode* pNext;

};

SNode* g_pHead = NULL;

void AddHead(DATA data)

{

SNode* p = (SNode*)malloc(sizeof(SNode));

p->data = data;

p->pNext = g_pHead;

g_pHead = p;

}

void Print()

{

SNode* p = g_pHead;

printf("List：");

while (p)//当节点的地址不为NULL

{

printf("%d ", p->data);

p = p->pNext;

}

printf(" ");

}

int main()

{

AddHead(1);

AddHead(2);

AddHead(3);

Print();

return 0;

}

程序运行结果如下：

(3)线性表顺序存储及实现扩展阅读：

双向链表框架：

#pragma once

typedef void* POSITION;

typedef int DATA;

struct SNode

{

DATA data;

SNode *pPrev, *pNext;

};

class CList

{

SNode *m_pHead, *m_pTail;

int m_nCount;

public:

CList();

~CList();

void RemoveAll();

DATA GetNext(POSITION &pos);

DATA GetPrev(POSITION &pos);

void AddHead(DATA data);

void AddTail(DATA data);

void RemoveAt(POSITION pos);

};

⑷ 1、线性表顺序存储方式操作2、线性表链式存储方法操作：。两个都用c语言

下面是从我的博客里面给你找的，你参考一下。更多的数据结构的内容，也可以去看我的博客。

/************************************************************
说明：
1、主函数内的代码是为了测试方便，可以自行修改。
2、宏定义NEWS是人机交互信息提示，若不需要，可修改为0。
3、若是windows系统，请将258行中的clear修改为cls。
4、在输入数据后，请多按一下回车，实现清屏。
环境：ubuntu12.04LTS、codeblocks10.05、2014-04-02
************************************************************/
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
#include<cstring>
#defineNEWS1
#defineLIST_INIT_SIZE100
#defineLIST_ADD_SIZE10
#defineNEW_SIZE(L->list_size+LIST_ADD_SIZE)
usingnamespacestd;
typedefintElem_Type;
typedefstruct
{
Elem_Type*data;//元素
intlen;//长度
intlist_size;//空间
}Sq_List;
typedefenum
{
OK=0,//正常
ERROR=-1,//逻辑异常
OVER=-2//内存异常
}Status;
/******************************
函数名：Init_List
功能：构造、初始化线性表
******************************/
Sq_List*Init_List(void)
{
Sq_List*L=(Sq_List*)malloc(sizeof(Sq_List));
if(!L)
exit(OVER);
L->data=(Elem_Type*)malloc(LIST_INIT_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);
L->len=0;
L->list_size=LIST_INIT_SIZE;
#if(NEWS)
cout<<"构造成功，已初始化"<<endl;
#endif
returnL;
}
/******************************
函数名：Destroy_List
功能：销毁线性表
******************************/
StatusDestroy_List(Sq_List*L)
{
free(L);
#if(NEWS)
cout<<"销毁成功，请不要再使用"<<endl;
#endif
returnOK;
}
/******************************
函数名：Clear_List
功能：清空线性表
******************************/
StatusClear_List(Sq_List*L)
{
memset(L->data,-1,sizeof(L->data));
L->len=0;
#if(NEWS)
cout<<"已全部清空"<<endl;
#endif
returnOK;
}
/******************************
函数名：Empty_List
功能：判断线性表是否为空
******************************/
boolEmpty_List(Sq_List*L)
{
returnL->len==0;
}
/******************************
函数名：Length_List
功能：获取线性表长度
******************************/
intLength_List(Sq_List*L)
{
returnL->len;
}
/******************************
函数名：Get_Elem_List
功能：指定位置获取元素
******************************/
StatusGet_Elem_List(Sq_List*L,intindex,Elem_Type*e)
{
if(!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"获取位置不合法"<<endl
<<"下面显示的数据是上次输入的num的值,请注意！！！"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
returnOK;
}
/******************************
函数名：Insert_List
功能：指定位置插入元素
******************************/
StatusInsert_List(Sq_List*L,intindex,Elem_Typee)
{
if(!(1<=index&&index<=Length_List(L)+1))
#if(NEWS)
{
cout<<"插入位置不合法"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
if(Length_List(L)>=L->list_size)
#if(NEWS)
cout<<"刚才增加了存储空间"<<endl;
#endif
L->data=(Elem_Type*)realloc(L->data,NEW_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);

L->list_size+=LIST_ADD_SIZE;

for(inti=Length_List(L);i>=index-1;i--)
L->data[i+1]=L->data[i];

L->data[index-1]=e;
L->len++;
#if(NEWS)
cout<<"插入成功"<<endl;
#endif
returnOK;
}
/******************************
函数名：Delete_List
功能：指定位置删除元素
******************************/
StatusDelete_List(Sq_List*L,intindex,Elem_Type*e)
{
if(Empty_List(L)||!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"删除位置不合法or目前是空表"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
for(inti=index;i<Length_List(L);i++)
L->data[i-1]=L->data[i];
#if(NEWS)
cout<<"删除成功"<<endl;
#endif
L->len--;
returnOK;
}
/******************************
函数名：Print_List
功能：输出所有元素
******************************/
StatusPrint_List(Sq_List*L)
{
if(Empty_List(L))
returnERROR;
inttemp;
for(inti=1;i<=Length_List(L);i++)
{
Get_Elem_List(L,i,&temp);
cout<<temp<<"";
}
cout<<endl;
returnOK;
}
/******************************
函数名：print_news
功能：方便用户选择
******************************/
voidprint_news(void)
{
cout<<" ********************"
<<"*****************************"<<endl
<<" * 0建立、初始化 *"<<endl
<<" * *"<<endl
<<" * 1插入元素 *"<<endl
<<" * *"<<endl
<<" * 2删除元素 *"<<endl
<<" * *"<<endl
<<" * 3销毁 *"<<endl
<<" * *"<<endl
<<" * 4获取表长 *"<<endl
<<" * *"<<endl
<<" * 5清空 *"<<endl
<<" * *"<<endl
<<" * 6获取元素 *"<<endl
<<" * *"<<endl
<<" * 7打印 *"<<endl
<<" * *"<<endl
<<" * 8退出程序 *"<<endl
<<" ********************"
<<"*****************************"<<endl;
}
intmain(void)
{
Sq_List*test=NULL;
while(true)
{
print_news();
intchoose,index,num;
cout<<"要进行什么操作？"<<endl;
cin>>choose;
switch(choose)
{
case0:
test=Init_List();break;
case1:
cout<<"插入位置"<<endl;
cin>>index;
cout<<"插入数据"<<endl;
cin>>num;
Insert_List(test,index,num);break;
case2:
cout<<"删除的位置"<<endl;
cin>>index;
Delete_List(test,index,&num);
cout<<"被删除的元素是："<<num<<endl;break;
case3:
Destroy_List(test);break;
case4:
cout<<Length_List(test)<<endl;break;
case5:
Clear_List(test);break;
case6:
cout<<"获取哪个位置的元素"<<endl;
cin>>index;
Get_Elem_List(test,index,&num);
cout<<num<<endl;break;
case7:
Print_List(test);break;
case8:
return0;
default:
break;
}
getchar();
getchar();
system("clear");
}
return0;
}

⑸ 线性表的顺序存储实验

你改下下面代码的标点就行了：
#include<iostream.h>
#define elemtype int
struct link
{ elemtype data；//元素类型
link *next； //指针类型，存放下一个元素地址
};

//头插法建立带头结点的单链表
link *hcreat()
{ link s,p;
elemtype i;
cout<<”输入多个结点数值(用空格分隔)，为0时算法结束”；
cin>>i；
p=new link；
p->next=NULL；
while(i) //当输入的数据不为0时，循环建单链表
{s=new link；
s->data=i；
s->next=p->next；
p->next=s；
cin>>i； }
return p；
}

//输出单链表
void print(1ink *head)
{
1ink *p；
p=head->next；
while(p->next!=NULL)
{
cout<<p->data<<”->”； //输出表中非最后一个元素
p=p->next；
}
cout<<p->data； //输出表中最后一个元素
cout<<endl；
}

∥在单链表head中查找值为x的结点
Link *Locate(1ink *head，elemtype x)
{
Link *p；
p=head->next；
while((p!=NULL)&&(p->data!=x))
p=p->next；
return p； }

//在head为头指针的单链表中，删除值为x的结点
void deletel(1ink *head，elemtype x)
{
1ink *p， *q；
q=head；
p=head->next；
while((p!=NULL)&&(p->data!=x))
{
q=p；
p=p->next；}
If(p==NULL) cout<<“要删除的结点不存在”；
else
q->next=p ->next；
delete(p)；
}
}
//在头指针head所指的单链表中，在值为x的结点之后插入值为y的结点
void insert(1ink *head，elemtype x，elemtype y)
｛ link *p， *s；
s=new link；
s->data=y；
if(head->next==NULL) //链表为空
{
head->next=s；
s->next=NULL：
}
p=Locate(head，x)；//调用查找算法 ‘
if(p==NULL)
cout<<”插入位置非法”：
else
(s->next=p->next；
p->next=s；
}
}

//将单链表p中所有值为x的元素修改成y
void change(1ink *p,elemtype x,elemtype y)
{
link *q；
q=p->next；
while(q!=NULL)
{ if(q->data==x) q->data=y；
q=q->next；
}
}

void count(1ink *h) //统计单链表中结点个数
{
1ink *p；int n=0；
p=h->next；
while(p!=NULL)
{n++；p=p->next；}
return n;
}


void main()
{ int n；
elemtype x，y；
link *p， *q；
p=hcreat()； //头插法建立链表
print(p)； //输出刚建立的单链表
cout<<”请输入要删除的元素”；
cin>>y；
deletel(p，y)；
print(p)； //输出删除后的结果
cout<<”请输入插入位置的元素值(将待插元素插入到它的后面)”;
cin>>x；
cout<<”请输入待插元素值”；
cin>>y；
insert(p，x，y)；
print(p)； //输出插入后的结果
cout<<”请输入要修改前、后的元素值”;
cin>>x>>y；
change(p，x，y)；
print(p)；
cout<<”请输入要查找的元素值”；
cin>>x；
q=Locate(p，x)；
if(q==NULL)cout<<x<<”不在表中，找不到!”<<endl；
else cout<<x<<”在表中，已找到!”<<endl；
n=count(p)；
cout<<”链表中结点个数为：”<<n<<endl：
}

⑹ 用C语言建立一个顺序存储的线性表并实现线性表的插入和删除操作

此顺序表实现了多个功能，代码很完善，我将其改成从键盘输入跟选择删除了，你根据你的需要自己再进行修改。

//common.h文件，头文件
#ifndef_COMMON_H_
#define_COMMON_H_

#include<stdio.h>
#include<stdlib.h>
#include<strings.h>
#include<assert.h>

#defineTRUE1
#defineFALSE0

#defineMAXSIZE100

typedefintdatatype;

typedefstruct
{
	datatypedata[MAXSIZE];
	intlength;
}sqnode,*sqlink;

voidcreat_sqlist(sqlink*sq);
voidset_empty_sqlist(sqlinksq);
intisempty_sqlist(sqlinksq);
intisfull_sqlist(sqlinksq);
intgetlength_sqlist(sqlinksq);
datatypegetelem(sqlinksq,inti);//i为第i个元素
intlocate_sqlist(sqlinksq,datatypex);//返回该元素在表中的位置
voidinsert_sqlist(sqlinksq,datatypex,inti);//表示在表中第i个位置前插入。
datatypedel_sqlist(sqlinksq,inti);//删除表中第i个元素
voidshow_sqlist(sqlinksq);

#endif

//线性表实现的c代码
#include"common.h"
voidcreat_sqlist(sqlink*sq)
{
	*sq=(sqlink)malloc(sizeof(sqnode));
	assert(*sq);
	bzero(*sq,sizeof(sqnode));
	(*sq)->length=0;
}

voidset_empty_sqlist(sqlinksq)
{
	sq->length=0;
}

intisempty_sqlist(sqlinksq)
{
	returnsq->length==0?TRUE:FALSE;
}

intisfull_sqlist(sqlinksq)
{
	returnsq->length==MAXSIZE?TRUE:FALSE;
}

intgetlength_sqlist(sqlinksq)
{
	returnsq->length;
}

datatypegetelem(sqlinksq,inti)//i为第i个元素
{
	if(i<1||i>getlength_sqlist(sq))
	{
		printf("iiswrong!
");
		returnFALSE;
	}
	returnsq->data[i-1];
}

intlocate_sqlist(sqlinksq,datatypex)//返回该元素在表中的枯耐位置
{
	intj=1;
	while(j<=getlength_sqlist(sq))
	{
		if(sq->data[j-1]==x)
			returnj;
		j++;
	}
	returnFALSE;
}
voidinsert_sqlist(sqlinksq,datatypex,inti)//表示在表中第i个没和春位置前插入。
{
	intj=1;
	if(isfull_sqlist(sq))
	{
		printf("sqlistisfull!
");
		return;
	}
	if(i<1||i>getlength_sqlist(sq)+1)
	{
		printf("iisnotintherange!
");
		return;
	}
	for(j=getlength_sqlist(sq)-1;j>=i-1;j--)
	{
		sq->data[j+1]=sq->data[j];
	}
	sq->data[i-1]=x;
	++sq->length;
}
datatypedel_sqlist(sqlinksq,inti)//删除表中第i个元素
{
	datatyperet;
	if(isempty_sqlist(sq))
	{
		printf("sqlistisempty!
");
		returnFALSE;
	}
	if(i<1||棚兆i>getlength_sqlist(sq))
	{
		printf("iisnotintherange!");
		returnFALSE;
	}
	for(i;i<getlength_sqlist(sq);i++)
		sq->data[i-1]=sq->data[i];
	--sq->length;
	returnret;
}

voidshow_sqlist(sqlinksq)
{
	intj=0;
	for(j;j<getlength_sqlist(sq);j++)
		printf("%d,",sq->data[j]);
	putchar('
');
}
//main函数
#include"common.h"

intmain(intargc,char*argv[])
{
	inti=0,n,id;
	intnum;
	printf("你要往顺序表中插入几个元素
");
	scanf("%d",&num);
	printf("请往顺序表中插入%d个元素：
",num);
	sqlinksq=NULL;
	creat_sqlist(&sq);
	while(i<num)
	{
	scanf("%d",&n);
		insert_sqlist(sq,n,1);
		i++;
	}
	printf("顺序表的存储如下：
");
	show_sqlist(sq);
	printf("你要删除第几个元素?
");
	scanf("%d",&id);
	del_sqlist(sq,id);
	printf("删除第%d个元素之后的顺序表为：
",id);
	show_sqlist(sq);
	return0;
}

⑺ 数据结构c语言版 使用线性表的顺序储存结构定义(静态)实现线性表的初

直接上源码吧。
/*线性表功能的实现*/
#include<stdio.h>
//定义常量 存储空间的初始化分配
#define MAXSIZE 20
#define TRUE 1
#define ERROR -1
#define FALSE 0
#define OK 1
//用typedef定义类型
typedef int Status;
typedef int ElemType;
//定义一个结构体类型
typedef struct{
ElemType data[MAXSIZE];
int length;
} SqList;
//初始化函数
Status initList(SqList *L){
L->length = 0;
return OK;
}
//返回线性表的长度
Status getListLength(SqList L){
return L.length;
}
//线性表为空返回true,否则返回false
Status listEmpty(SqList L){
if(L.length == 0){
return TRUE;
}
return FALSE;
}
//线性表清空,长度为0
Status clearList(SqList *L){
L->length = 0;
return OK;
}
//获取指定的元素的值,返回下标为i - 1的元素,赋值给e
Status getElem(SqList L, int i, ElemType *e){
//判断元素位置是否合法[i]
if(i > L.length || i < 1){
printf("查找的位置不正确 \n");
return ERROR;
}
//判断线性表是否为空
if(listEmpty(L)){
return ERROR;
}
*e = L.data[i - 1];
return OK;
}
//在线性表中查找指定的e相等的元素,如果查找成功,返回该元素的下标,否则返回ERROR
Status locateElem(SqList L, ElemType e){
int i;
for(i = 0; i < L.length - 1; i++){
if(L.data[i] == e){
return i;
}
}
printf("没有查找到元素 %d 指定的下标\n",e);
return ERROR;
}
//自动创建 MAXSIZE 个元素,并赋值为0
Status createList(SqList *L){
int i;
for(i = 0; i < 10; i++){
L->data[i] = 0;
}
L->length = 10;
return OK;
}
//在线性表中第i个位置前插入新元素e
Status listInsert(SqList *L, int i, ElemType e){
//判断长度是否可以允许插入新的数据
if(L->length >= MAXSIZE){
printf("空间已满,不能再插入数据\n");
return FALSE;
}
//判断插入位置的合法性
if(i < 1 || i > L->length) {
printf("插入位置不正确\n");
return FALSE;
}
int j;
for(j = L->length - 1; j >= i; j--){
L->data[j] = L->data[j - 1];
}
L->data[i - 1] = e;
L->length++;
return TRUE;
}
//删除线性表中第i个元素,成功后表长减1,用e返回其值
Status deleteList(SqList *L, int i, ElemType *e){
//判断线性表是否为空
if(listEmpty(*L)){
return ERROR;
}
//判断删除的位置是否合法
if(i < 1 || i > L->length) {
printf("删除位置不合法\n");
return ERROR;
}
*e = L->data[i - 1];
for(i; i < L->length; i++){
L->data[i - 1] = L->data[i];
}
L->length--;
return TRUE;
}
//遍历线性表
Status listTraverse(SqList L){
int i;
for(i = 0; i < L.length; i++){
printf("%d ",L.data[i]);
}
printf("\n");
return OK;
}
//主程序
int main(void){
SqList L;
ElemType e;
initList(&L);
int option = 1;
int input_number;
int res;
ElemType input_value;
printf("\n1.遍历线性表 \n2.创建线性表 \n3.清空线性表 \n4.线性表插入 \n5.查找表中元素 \n6.判断元素是否在表中 \n7.删除某个元素 \n8.线性表长度\n9.线性表是否为空\n0.退出 \n请选择你的操作：\n");
while(option){
scanf("%d",&option);
switch(option){
case 0:
return OK;
break;
case 1:
listTraverse(L);
break;
case 2:
createList(&L);
listTraverse(L);
break;
case 3:
clearList(&L);
listTraverse(L);
break;
case 4:
printf("请输入插入的位置:");
scanf("%d",&input_number);
printf("\n");
printf("请输入插入的值:");
scanf("%d",&input_value);
printf("\n");
listInsert(&L, input_number, input_value);
listTraverse(L);
break;
case 5:
printf("请输入要查找的位置:");
scanf("%d",&input_number);
printf("\n");
getElem(L, input_number, &input_value);
printf("第%d个元素的值为:%d\n",input_number,input_value);
break;
case 6:
printf("请输入要查找的元素:");
scanf("%d",&input_value);
printf("\n");
res = locateElem(L, input_value);
if(res != ERROR){
printf("值为%d在表中的第%d个位置\n",input_value,input_number);
}
break;
case 7:
printf("要删除第几个元素？");
scanf("%d",&input_number);
printf("\n");
deleteList(&L, input_number, &input_value);
listTraverse(L);
break;
case 8:
res = getListLength(L);
printf("线性表的长度是:%d",res);
break;
case 9:
res = listEmpty(L);
if(res){
printf("线性表的是空的");
}else{
printf("线性表的是不是空的");
}
break;
}
}
return OK;
}

线性表的特征是:
1. 元素之间是有序的,如果元素存在多个,则第一个元素无前驱,最后一个无后继,其它元素都有且只有一个前驱和后继.
2. 元素个数是有限的. 当n=0是,称为空表
线性表实现方式有两种,分别是顺序存储结构和链式存储结构,它们之间各有优缺点 . 根据需求的不同进行选择不同的存储结构.
线性表存储结构的优缺点
优点:
1. 无须为表中元素之前的逻辑关系而增加额外的存储空间
2. 可以快速的存取表中的任一位置的元素
缺点:
1. 插入和删除操作需要移动大量元素
2. 当线性表长度变化较大时,难以确定存储空间的容量.
3. 造成存储空间的”碎片”.

⑻ 给出线性表的顺序存储的定义及程序实现。

#include<stdio.h>
#include"茄数string"
#include<conio.h>
typedef int ElemType;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
//初始化
typedef struct
{
ElemType elem[MAXSIZE];
int last;
}SeqList;
//创建空表
void IntList(SeqList *L)
{
L->last=-1;
}
//判断空表
int EmptyList(SeqList *L)
{
if(L->last==-1)
{
return OK;
}
else return ERROR;
}
//输入递增有序顺序表
void putseqList(SeqList *L,int n)
{
int i;
for(i=0;i<n;i++)
scanf("%d",&(L->elem[i]));
L->last=L->last+n;
}
//求表长
int LenList(SeqList *L)
{
int Len;
Len=L->last+1;
return Len;
}
//查找元素
int Locate(SeqList *L,int e)
{
int s;
if(L->last==-1)
return -1;
for(s=0;s<=L->last;s++)
{
if(L->elem[s]==e)
return (s+1);
else return -1;
}
}
//插入元素
int InsList(SeqList *L,int i,int e)
{
int k;
if((i<1)||(i>L->last+2))
{
printf("插入位置不合理");
return(ERROR);
}
if(L->last>=MAXSIZE-1)
{
printf("表已满无法插入");
return(ERROR);
}
for(k=L->last;k>=i-1;k--)
L->elem[k+1]=L->elem[k];
L->elem[i-1]=e;
L->last++;
return(OK);
}
//删除操作
int DeiList(SeqList *L,int f,int *e)
{
int m;
if((f<1)||(f>L->last+1))
{
printf("删除位置不合理");
return(ERROR);
}
*e=L->elem[f-1];
for(m=f;m<=L->last;m++)
L->elem[m-1]=L->elem[m];
L->last--;
return(OK);
}
//合并操作
void merge(SeqList *LA, SeqList *LB, SeqList *LC)
{
int i,j,k;
i=0;j=0;k=0;
while(i<=LA->last&&j<=LB->last)
if(LA->elem[i]<=LB->elem[j])
{
LC->elem[k]= LA->elem[i];
i++;
k++;
}
else
{
LC->elem[k]=LB->elem[j];
j++;
k++;
}
while(i<=LA->last) /*当表LA有剩余元素时，则将表LA余下的猜纳好元素赋给表LC*/
{
LC->elem[k]= LA->elem[i];
i++;
k++;
}
while(j<=LB->last) /*当表LB有剩余元素时，则将表LB余下的元素赋给表LC*/
{
LC->elem[k]= LB->elem[j];
j++;
k++;
}
LC->last=LA->last+LB->last+1;
}

//输出元素
int OutputSeqList(SeqList *L)
{
int t;
for(t=0;t<=L->last;t++)
printf("%d ",L->elem[t]);
return(L->elem[t]);
}
//主程序
void main()
{
int z,x,h,u,r,WF=1,La,Lb;
char ch;
SeqList L,LA,LB,LC;
while(WF)
{
printf("\n");
printf("--------------------------------------------\n");
printf("实现顺序表穗铅基本操作\n");
printf("0.退出\n");
printf("1.创建顺序表\n");
printf("2.在顺序表中插入元素 \n");
printf("3.在顺序表中删除元素\n");
printf("4.合并两个顺序表\n");
printf("请选择所要实施的操作\n:");
printf("--------------------------------------------\n");
ch=getch();
putchar(ch);
putchar('\n');
//选择功能里无对应选项选项，执行此返回操作
if(ch<'0'||ch>'7')
{
printf("无此功能选项，请重新选择！\n");
WF=1;
}
else
//采用switch语句实现菜单的操作
switch(ch)
{
//实现选择0的操作
case '0':printf("退出\n");break;
//实现选择1的操作
case '1': printf("创建顺序表\n");
IntList(&L);
printf("请输入顺序表表长:\n");
scanf("%d",&z);
printf("请输入顺序表中的元素:\n");
putseqList(&L,z);
LenList(&L);
printf("表长为%d\n",LenList(&L));
printf("顺序表为\n");
OutputSeqList(&L);
break;
//实现选择2的操作
case '2':
if(LenList(&L)<=0)
{ printf("未输入任何值，请先创建！\n");
break;
}
printf(".在顺序表中插入元素\n ");
printf("请输入要插入的元素的位置和元素(用空格隔开): \n");
scanf("%d %d",&x,&h);
InsList(&L,x,h);
printf("在第%d位子插入元素%d后的顺序表为\n:",x,h);
OutputSeqList(&L);
break;
//实现选择3的操作
case '3':
if(LenList(&L)<=0)
{ printf("未输入任何值，请先创建！\n");
break;
}
printf("在顺序表中删除元素\n");
printf("请输入要删除的元素的位置: \n");
scanf("%d",&u);
DeiList(&L,u,&r);
printf("在删除第%d个元素后的顺序表为:",u);
OutputSeqList(&L);
break;
//实现选择4的操作
case '4':printf("合并两个顺序表:\n");
IntList(&LA);
IntList(&LB);
IntList(&LC);
//对合并前顺序表1的输入
printf("请输入顺序表1表长:\n");
scanf("%d",&La);
printf("请输入顺序表1中的元素:\n");
putseqList(&LA,La);
LenList(&LA);
printf("表长为%d\n",LenList(&LA));
printf("顺序表1为\n");
OutputSeqList(&LA);
printf("\n");
//对合并前顺序表2的输入
printf("请输入顺序表2表长:\n");
scanf("%d",&Lb);
printf("请输入顺序表2中的元素:\n");
putseqList(&LB,Lb);
LenList(&LB);
printf("表长为%d\n",LenList(&LB));
printf("顺序表1为\n");
OutputSeqList(&LB);
printf("\n");
//合并操作及对合并后的饿顺序表的操作
merge(&LA,&LB,&LC);
OutputSeqList(&LC);
printf("\n");
break;
}
}

}

⑼ 线性表的基本操作在顺序存储结构上的实现

/* =======================
* Filename:delet.c
* -----------------------
* Author:hufeng Date:2007/10/23
* -----------------------------
* ========================
*/
/姿答仔迹汪* header file */
#include <stdio.h>
#include <stdlib.h>
#define M 10

/* =================
* Function:insert
* Reaction:insert x in
* the i place
* ==================
*/
void delet(int a[], int i)
{
int j; /* declaration */举正

if (i < 1 || i > a[0] + 1)
{
printf("error");
exit(0);
}

for (j = i + 1; j <= a[0]; j++) /* all elem after i backward */
{
a[j - 1] = a[j];
}

/* read x */

a[0] = a[0] - 1;

}

/* ========================
* Function:Creat_list
* reaction:creat a list
* =========================
*/

void creat_list(int a[], int n)
{
int i; /* declaration */
int j;
int x;

a[1] = rand()%100; /* read a[1] */

for (i = 2; i <= n; i++)
{
x = rand()%100;
for (j = 1; j <= i - 1; j++)
{
if (x == a[j])
{
break;
}
}
if (j > i - 1)
{
a[i] = x;
}
else
i--;
}
a[0] = n;
}

/* ========================
* Function:print_list
* Reaction:display the result
* =========================
*/
void print_list(int a[] )
{
int i; /* declartion a cycle variable */

printf("\n");

for (i = 1; i <= a[0]; i++)
{
printf("%5d",a[i]);
}

printf("\n");
}

int main()
{
int a[M]; /* declaration arrey a */
int num;
int place;

creat_list(a, 8); /* creat list a */
print_list(a); /* print list a */

printf("Pleae enter where you want to delet:\n");
scanf("%d",&place);
printf("The place is :%d\n",place);

delet(a, place);
print_list(a);

getch();
return 0;
}

⑽ 数据结构实验，线性表的顺序存储结构的实现

C++代码编写的

#include<iostream>
#include<string>
usingnamespacestd;
typedefintElemType;
typedefstructLNode
{
ElemTypedata;
structLNode*next;
}LinkList;
voidCreatListR(LinkList*&L,ElemTypea[],intn)
{
LinkList*s,*r;
inti;
//L=(LinkList*)malloc(sizeof(LinkList));
L=newLinkList();
r=L;
for(i=0;i<n;i++)
{
//s=(LinkList*)malloc(sizeof(LinkList));
s=newLinkList();
s->data=a[i];
好信r->next=s;
r=s;
}
r->next=NULL;
}
voidDispList(LinkList*L)
{
LinkList*p=L->next;
while(p!=NULL)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
intListInsert(LinkList*&L,inti,ElemTypee)
{
intj=0;
LinkList*p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return0;
else
{
s=newLinkList();
s->data=e;
s->next=p->next;
p->next=s;
return1;
}
}
intListDelete(LinkList*&L,inti)
{
intj=0;
LinkList*p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;
槐皮p=p->next;
}
if(p==NULL)
{
return0;
}
else
{
q=p->next;
if(q==NULL)
{
return0;
}
p->next=q->next;
inta=q->data;
free(q);
returna;
}
}
intmain()
{
LinkList*L,*L1;
铅袜差inta[]={1,5,7,9,12,18,19,20,30,43,45,56,41,42,78};
intn=15,i,x,y,j;
CreatListR(L,a,n);
DispList(L);
cout<<"请输入i"<<endl;
cin>>i;
cout<<"请输入x"<<endl;
cin>>x;
ListInsert(L,i,x);
DispList(L);
cout<<"请输入j"<<endl;
cin>>j;
y=ListDelete(L,j);
DispList(L);
cout<<y<<endl;
return0;
}