数据结构实验指导书(网络1401-1402).docx

陕西理工大学重点课程《数据结构》实验指导书
使用班级：网络1401-1402
数学与计算机科学学院
计算机科学与技术系
2016年9月
return(S->top==-1 ?TRUE:FALSE);I
int Isfull(SeqStack *S)(
return(S->top==Stack_size- 1?TRUE:FALSE);}
int Push(SeqStack *S,char x)(
if(S->top==Stack_size-1)
(printf(”栈满\n”)；
return FALSE;
)
else
{
S->top++;
S->data[S->top]=x; return TRUE;
I}
int Pushn(SeqStack *S,int x){
if(S->top==Stack_size-1)
(printf("栈满 \n”);
return FALSE;
)
else
(S->top++;
S->data[S->topJ=x;return TRUE;
int Popn(ScqStack *S,int *x)( if(S->top==-l)
{
printf(”操作数为空\n“); return FALSE;
}
else
(*x=S->data[S->top];
S->top-; return TRUE;
}I
int Pop(ScqStack *S,char *x)(
if(S->top==-l){ printf(”操作符为空\n”); return FALSE;
}
else
(*x=S->data[S->top]; S->top-;
return TRUE;
}I
char Gettop(SeqStack *S)I
if(S->top==-l)
(printfC'栈为空\n”)； return FALSE;
}
else
(retum(S->data[S->topJ);
int Isoperator(char ch){
int i; for(i=0;iv7;i++)
(if(ch==ops[i])
return TRUE;
)
return FALSE;char Compare(char ch 1 ,char ch2)
char pri;int priority; for(i=0;i<7;i++) {
if(chl==opsfi]) m=i;if(ch2==ops[i])
n=i;
}
return cmp[m][nj;}
int Execute(int a ,char op,int b) {
int result;
switch(op)
(case '+':result=a+b; break;
case '-,:result=a-b; break;case '*':result=a*b; break;
case 7':result=a/b; break;
}
return result;int ExpEvaluation()
(
int a,b,v,temp;
char op,ch;
char *str;
int i=0;
SeqStack OPTR;
SeqStack OPND;
InitStack(&OPTR);InitStack(&OPND); Pushn(&OPTR；#');
printf(”输入表达式，以#结束\n”)； str=(char *)malloc(5()*sizeof(char)); gets(str);
ch=str[i];
i++；while(ch!=,#,||Gettop(&OPTR)!='#') {
if(!Isoperator(ch))temp=ch-'O*;
ch=str[ij;i++；
whilc(! Isoperator(ch)){
temp=temp* 10+ch-'O'; ch=str[i];
i++；
} Pushn(&OPND,temp);)
else( switch(Compare(Gettop(&OPTR),ch)) {
case 'v'：Push(&OPTR,ch);
ch=str[i];
i++； break;case ’>':Pop(&OPTR,&op);
Popn(&OPND,&b);
Popn(&OPND,&a); v=Execute(a,op,b); Pushn(&OPND,v); break;case:Pop(&OPTR,&op);
ch=str[ij;
i++； break:
}}
}
v=Gcttop(&OPND);
return v;I
void main()
int result;
system("clr");
result=ExpEvaluation();
printf（"表达式的结果为：%d\nu,result）;
}
实验四队列
一、实验性质：必做二、实验学时：2学时
三、实验类型：验证四、实验目的：
1. 掌握队列顺序存储结构和链式结构，以便在实际背景下灵活运用。
2. 掌握队列的特点，即进先出的原则。
五、实验内容：
1）实现队列入队、出队操作；
2）利用栈和队列知识实现停车场管理。
根据题目要求，停车场只有一个大门，因此可用一个栈来模拟；而当栈满后, 继续来的车辆只能停在便道上，根据便道停车的特点，可知这可以用一个队列来 模拟，安排队的车辆先离开便道，进入停车场。由于在停车场中间的车辆可以提 前离开停车场，而且要求在离开车辆到停车场大门之间的车辆都必须先离开停车 场，让此车离去，然后再让这些车辆依原来的次序进入停车场，因此在一个栈和 一个队列的基础上，还需要有一个地方保存为了让路离开停车场的车辆，很显然 这也应该用一个栈来模拟。因此本题中用到两个栈和一个队列。
对于停车场和车辆规避所，有车辆进入和车辆离去两个动作，这就是栈的进 栈和出栈操作，只是还允许排在中间的车辆先离开停车场，因此在栈中需要进行 查找。而对于便道，也有入队列和出队列的操作，同样允许排在中间的车辆先离 去队列。这样基本动作只需利用栈和队列的基本操作就可实现。
六、程序实现：
#include "stdio.h" #include',stdlib.h” #define N 5 #define M 10 typedef struct {
int num; int arrtime;
} Stacktype; typedef struct
〃定义停车场长度
〃定义栈元素的类型
〃定义栈

Stacktype stack[N];
int top;} Stack;
typcdef struct node〃定义队列节点类型{
int num;
struct node *next;}Queneptr;
typedef struct// 定义队列(
Queneptr * front, *rear;JQuene;
void initstack(Stack *s)〃初始化栈{
s->top=-1;)
int push(Stack *s,Stacktype x) 〃数据元素X进入指针S所指的栈(
if(s->top=N-l)
return(O);
else(s->stack[++s->top]=x;
return(l);
)}
Stacktype pop(Stack *s){
Stacktypc x;
if(s->top<0)
x.num=();
x.aiTtime=O;
return(x);〃如果栈不空，返回栈顶元素
}
else
{
x=s->stack [s->top];
s->top-;
return x;
}}
void initquene(Quene *s) 〃初始化队列(
s->front=(Queneptr*)malloc(sizeof(Queneptr));//产生一个新结点，作为头结点 s->rear=s->front;
s->front->next=NULL;
s->front->num=0;〃头结点的NUM保存队列元素的个数}
void enquene(Quene *s,int num) 〃数据入队列{
Queneptr *p;
p=(Queneptr*)malloc(sizeof(Queneptr));p->num=num; p->next=NULL;
s->rear->next=p;s->rear=p; s->front->num++;
}int delquene(Quene *s)
Queneptr *p;
int n;
if (s->front==s->rear)
〃如果队列空
return(O);
else
p=s->front->next; s->front->next=p->next; if (p->next==NULL) s->rear=s->front;
n=p->num;
free(p);
s->front->num—;return(n);
()
void arrive(Stack *sl,Quene *p,Stacktype x){
int f;
f=push(sl,x);〃新到达的车辆入停车栈
if(f==O)
{
enquene(p,x.num);〃如果停车场满，就进入队列
printf("the %d car stops the %d seat of the quene\n",x.num,p->front->num); )
else printf("the %d car stops the %d seat of the stack\nn,x.num,s 1 ->top+1);}
void leave(Stack *sl,Stack *s2,Quene *p,Stacktype x) 〃处理车辆离去函数 {
int n,f=0;
Stacktype y;
Queneptr *q;
while((s 1 ->top>- !)&&(! f))
(y=pop(sl);
if(y.num!=x.num)n=push(s2,y);
else f=l;
}if(y.num==x.num) 〃如果栈顶元素不是要离开的车辆，就将其放入车辆规避所 (
printf("thc money of the %d is %d yuan\nM,y.num,(x.arrtime-y.arrtime)*M); while(s2->top>-l)
(
y=pop(s2); f=push(sl,y);
}
n=delquene(p);if(n)〃在停车场中找到要离开的车辆
{
y.num=n;
y.arrtime=x.arrtime;
f=push(sl,y);
printf(Hthe %d car stops the %d seat of the stak\n",y.num,s 1 ->top+1);
)
}else
{
while(s2->top>-1)〃车辆规避所不空，将其全放回停车场
(y=pop(s2);f=push(s l,y);
}
q=p->front;f=0;
while(f==O&&q->next!=NULL)if(q->next->num!=x.num) 〃如果便道上有车辆，将第一辆车放入停车场 q=q->next;
else
(
q->next=q->next->next;p->front->num—;
《数据结构》上机实验的目的和要求.・・・.1实验一线性表的基本操作2
实验二链表的基本操作.6实验三栈7
实验四队列12实验五二叉树的操作..19
实验六图的有关操作.22实验七电话号码查询系统的设计与实现.29
if(q->next==NULL)p->rear=p->front;
printf("lhe %d car leave the quene\n",x.num);f=l；
}
if(仁二0)〃在便道上没有找到要离开的车辆，输出数据错误
printf("error!the stack and the quene have no the%d car\n",x.num);)
)void main()〃停车场模拟
{
char ch;
int cord;
Stack *sl,*s2;
Quene *p;
Stacktype x;
int i=1;//clrscr();
// system("clr");
s 1 =(Stack*)malloc(sizeof(Stack));
s2=(Stack*)malloc(sizeof(Stack));
p=(Quene*)malloc(sizeof(Quene));
initstack(sl);
initstack(s2);〃初始化停车规避所栈
initquene(p);〃初始化便道队列do
{
printf(" \n主菜单\n");
printf("l进入停车场\n");
printf("2离开停车场\n”)；
printf(M3 退出 \n”)；
printf(H\nM);
printf(”请输入你的选择(1, 2, 3) ”); scanf(”％d”,&cord);
switch(cord)
/*printf("what do you want to do?\n");
printf("input---(Add/Del/Exit):");
scanf("%c",&ch);
switch (ch)*/
(
case 1:
printf(H请输入车辆到达序号:\n”)； scanf("%d",&x.num);print"请输入车辆到达时间:\n”)； scanf("%d",&x.arrtime);
arrive(sl,p,x);〃车辆到达break;
case 2:
printfC*请输入车辆离开序号:\n”)； scanf("%d",&x.num); printf(”请输入离开时间:\n”)； scanf(”％d”,&x.arrtime);
leave(s 1 ,s2,p,x);〃车辆离开
break;
case 3:/*printf("the end!");i=0;*/exit(O);
break;default:{printf("输入不对，请重新输入:\n"); break;
})
}while(i<=3);//ch=getchar();
}
实验五二叉树的操作
一、实验性质：必做二、实验学时:4学时
三、实验类型：验证四、实验目的：
掌握二叉树的定义、性质及存储方式，各种遍历算法。
五、实验内容：
采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序遍历 的操作，求所有叶子结点总数的操作。
六、程序实现
typcdef struct node(
char data;
struct node *lc;
struct node *rc;}*BiTree;
ini m=0;void Prctraverse(B iTree t)先序遍历
(
if(t!二NULL)
{pr intf(" %c" ,t->data);
Pretraverse(t->lc);Pretraverse(t->rc);
})
void Inorder(BiTree t)中序遍历
void Postorder(BiTree t)后序遍历 {
Ivoid creat(BiTree *t)
{
char ch;
//printf(”请输入数据\n”)；
scanf("%c",&ch);
if(ch='#')
{*l=NULL;
return;
}
else
(
*t=(BiTree)malloc(sizeof(struct node)); (*t)->data=ch;
printf(" %c 二 ch);creat(&((*t)->lc));
creat(&((*t)->rc));
)}
void main(){
BiTree t;
systeni(nclr");
int cord;
do
printf("\n
二叉树相关操作
\n”);
printfC'
1
建立二叉树
\n”)；
printf("
2
先序遍历二叉树
\n”)；
printfC'
3
中序遍历二叉树
\n")；

printf(H4后序遍历二叉树，统计叶子结点数\n”)；printfC* 5程序运行结束\nu);
printfC\n”)；printf(”请输入你的选择(1, 2, 3, 4, 5):”)； scanf("%d",&cord);
switch(cord)(
case 1:
{creat(&t);
printf(”二叉树建立完成，请继续执行其他操作\n”); (break;case 2:
{Pretraverse(t);
printf(”先序遍历完成\n”)；)break;
case 3:
{Inordcr(t);
printf(”中序遍历完成\n”);)break;
case 4:
{ Postorder(t);
printfC*后序遍历完成\n”)； printf(”叶子结果数为%3d”,m);)break;
case 5:
printf(H二叉树程序执行完毕！ \n”)； exit(O);)
)while(cord<=5);
实验六图的有关操作
一、实验性质：必做二、实验学时:4学时
三、实验类型：验证四、实验目的
掌握有向图和无向图的概念；掌握邻接矩阵和邻接链表建立图的存储结构； 掌握DFS及BFS对图的遍历操作；了解图结构在人工智能、工程等领域的广泛应 用。
五、实验内容
采用邻接矩阵和邻接表作为图的存储结构，完成无向图的DFS及BFS操作。
六、程序实现
1. 邻接矩阵作为存储结构的程序示例#include,,stdio.hn
#includeustdlib.h”#define Max Vertex Num 10()〃定义最大顶点数
typedef struct)
char vexs[MaxVertexNum]；〃顶点表
int edges[MaxVertexNum][MaxVertexNum]； 〃邻接矩阵，可看作边表
int n,e；〃图中的顶点数n和边数eJMGraph；〃用邻接矩阵表示的图的类型
〃建立邻接矩阵void CreatMGraph(MGraph *G)
{
int i,j,k；
char a；
printf(nInput VertexNum(n) and EdgesNum(e):")； scanf(”％d,%d”,&G->n,&G->e)；〃输入顶点数和边数
scanf("%c",&a)；
printf("Input Vertex string:")；
for(i=0； i<G->n； i++)
(
scanf("%c",&a)；
G->vexsfi]=a；〃读入顶点信息，建立顶点表
for(i=0； i<G->n； i++)for(j=0； j<G->n； j++)
G->edges[i]|j]=O；〃初始化邻接矩阵
printf("Input edges,Creat Adjacency Matrix\n")；
for(k=0； kvG->e； k++) (〃读入e条边，建立邻接矩阵
scanf(”％d%d”,&i,&j)；〃输入边(Vi, Vj)的顶点序号
G->edgesliJ[jJ=l；
G->edges[j][i]=l；〃若为无向图，矩阵为对称矩阵；若建立有向图，去掉该条语句
}}
〃定义标志向量，为全局变量typedef enum{FALSE,TRUE} Boolean；
Boolean visited[MaxVertexNum]:
〃DFS：深度优先遍历的递归算法void DFSM(MGraph *G,int i)
〃访问顶点Vi
〃置已访问标志
〃依次搜索Vi的邻接点
{〃以Vi为出发点对邻接矩阵表示的图G进行DFS搜索，邻接矩阵是0, 1矩阵 int j； printf("%c",G->vexs[i])； visitcd[i]=TRUE； for(j=0； j<G->n； j++)
if(G->edges[i][j]== 1 && ! visited。])// (Vi,

// (Vi,
DFSM(Gj);
Vj) eE,且Vj未访问过，故Vj为新出发点
}void DFS(MGraph *G)
int i；
for(i=0； i<G->n； visited[i]=FALSE； for(i=0； ivG->n； if(!visited[i])
DFSM(Qi)；
i++)
i++)
〃标志向量初始化
//Vi未访问过
〃以Vi为源点开始DFS搜索
)
//BFS：广度优先遍历void BFS(MGraph *G,int k)(〃以Vk为源点对用邻接矩阵表示的图G进行广度优先搜索
int i,j,f=O,r=O；
〃定义队列
int cq[MaxVertexNum]:
〃标志向量初始化
for(i=0； i<G->n； i++)
visitcd[i]=FALSE；
〃队列初始化 〃访问源点Vk
for(i=0； i<G->n； i++)
cqlij=-l；
printf("%c",G->vexs[k])；
//Vk己访问，将其入队。注意，实际上是将其序号入队 〃队非空则执行
visited[k]=TRUE；
cq[r]=k： while(cq[f]!=-l) (i=cq[f|； f=f+l；〃Vf 出队
for(j=0； j<G->n； j++)〃依次 Vi 的邻接点 Vj〃访问Vj

〃访问Vj
〃访问过Vj入队
if(G->edges[i]|j]==l && !visited。]) { //Vj 未访问 printf("%c",G->vexs[j])； visited[j]=TRUE； r=r+1； cq[rl=j；
))
//mainvoid main()
int 1；
MGraph *G；
〃为图G中请内存空间
G=(MGraph *)malloc(sizeof(MGraph))；
CreatMGraph(G)；〃建立邻接矩阵
printf(MPrint Graph DFS:，
DFS(G)；〃深度优先遍历
printf(”\n，
printfC'Print Graph BFS:")；
BFS(G,3)；〃以序号为3的顶点开始广度优先遍历
printf(,,\nM)；
执行顺序：
Input VertexNum(n) and EdgesNum(e): 8, 9I叩ut Vertex string: 01234567
Input edges,Creat Adjacency Matrix013。
02\1 3
1 425
26 图G的示例37
4756
Print Graph DFS: 01374256Print Graph BFS: 31704256
2. 邻接链表作为存储结构程序示例#include"stdio.h"
#inc】ude”stdlib.h”typedef VertexNode AdjList[MaxVertexNum] ；//Adj Li st 是邻接表类型
#define MaxVertexNum 50
〃定义最大顶点数
typedef struct node{ int adj vex； struct node *next：
JEdgeNode；
〃边表结点 〃邻接点域
〃链域
typedef struct vnode ( char vertex ； EdgeNodc *firstcdge；
} VertexNode；
〃顶点表结点 〃顶点域
〃边表头指针

typedef struct (
Adj List adj list；
〃邻接表
int n,e；
( ALGraph ；
〃图中当前顶点数和边数
〃图类型
〃建立图的邻接表
《数据结构》上机实验的目的和要求
通过上机实验加深对课程内容的理解，增加感性认识，提高软件设计、编写 及调试程序的能力。
要求所编的程序能正确运行，并提交实验报告。实验报告的基本要求为：
1、需求分析：陈述程序设计的任务，强调程序要做什么，明确规定：
(1) 输入的形式和输出值的范围；
(2) 输出的形式；
(3) 程序所能达到的功能；
(4) 测试数据：包括正确的输入输出结果和错误的输入及输出结果。
2、概要设计：说明用到的数据结构定义、主程序的流程及各程序模块之间的 调用关系。
3、详细设计：提交带注释的源程序或者用伪代码写出每个操作所涉及的算 法。
4、调试分析：
(1) 调试过程中所遇到的问题及解决方法；
(2) 算法的时空分析；
(3) 经验与体会。
5、用户使用说明：说明如何使用你的程序，详细列出每一步操作步骤。
6、测试结果：列出对于给定的输入所产生的输出结果。若有可能，测试随输 入规模的增长所用算法的实际运行时间的变化。
void CreatALGraph(ALGraph *G)(
int i,j,k；
char a：
EdgeNode *s；〃定义边表结点
printf("Input VertexNum(n) and EdgcsNum(e):")；
scanf(”％d,%d”,&G->n,&G->e)；〃读入顶点数和边数
scanf("%cH,&a)；
printf("Input Vertex string:")；
for(i=0； i<G->n； i++)〃建立边表
{
scanf(”％c”,&a)；
G->adjlist[i].vertex=a；〃读入顶点信息
G->adj 1 ist [ i]. firstedge=NULL:〃边表置为空表
}
printf("Input edges,Creat Adjacency List\n”)；
for(k=0； k<G->e； k++) ( 〃建立边表 scanf(”％d%d”,&i,&j)；〃读入边(Vi, Vj)的顶点对序号
s=(EdgeNode *)malloc(sizcof(EdgcNodc))；〃生成边表结点
s->adjvex=j；〃邻接点序号为j
s->next=G->adj 1 ist [ i]. firstedge ；
G->adjlistfi].firstedge=s;〃将新结点*S插入顶点Vi的边表头部
s=(EdgeNode *)malloc(sizeof(EdgeNode))； s->adjvex=i；〃邻接点序号为i
s->next=G->adj list|j]. firstedge ；
G->adj 1 ist[j].firstedge=s:〃将新结点*S插入顶点Vj的边表头部
})
〃定义标志向量，为全局变量typedef enum{FALSE,TRUE) Boolean；
Boolean visited[MaxVertexNum]:
〃DFS：深度优先遍历的递归算法void DFSM(ALGraph *G,int i)
{〃以Vi为出发点对邻接链表表示的图G进行DFS搜索
EdgeNode *p：
printf(M%c",G->adjlisl[i].vertex)； 〃访问顶点 Vi visited[i]=TRUE；〃标记 Vi 己访问
p=G->adjlist[i].firstedge；〃取 Vi 边表的头指针
while(p)(〃依次搜索Vi的邻接点Vj,这里j=p->adjvexif(! visited[p->adjvex]) DFSM(G,p->adjvex)； p=p->next；
}
)
void DFS(ALGraph *G)
{
int i；

if(! visited[p->adjvex]) DFSM(G,p->adjvex)； p=p->next；
}
)
void DFS(ALGraph *G)
{
int i；
〃若Vj尚未被访问
〃则以Vj为出发点向纵深搜索
〃找Vi的下一个邻接点
for(i=0； i<G->n： i++) visited[i]=FALSE； for(i=()； i<G->n； i++) if(!visited[i])
DFSM(Gi);

for(i=0； i<G->n： i++) visited[i]=FALSE； for(i=()； i<G->n； i++) if(!visited[i])
DFSM(Gi);
〃标志向量初始化
//Vi未访问过
〃以Vi为源点开始DFS搜索
}
//BFS：广度优先遍历
void BFS(ALGraph *G,int k)
(〃以Vk为源点对用邻接链表表示的图G进行广度优先搜索
int i,f=O,r=O；
EdgeNode *p；
int cq[MaxVertexNum]: for(i=0； i<G->n； i++) visited[i]=FALSE； for(i=0； i<=G->n； i++)

EdgeNode *p；
int cq[MaxVertexNum]: for(i=0； i<G->n； i++) visited[i]=FALSE； for(i=0； i<=G->n； i++)
cq[i]=-l；
printf(M%c",G->adjlist[k].vertex)；
〃定义FIFO队列
〃标志向量初始化
〃初始化标志向量
〃访问源点Vk

visited[k]=TRUE；
cq(r]=k； 〃Vk己访问，将其入队。注意，实际上是将其序号入队 while(cq[f]!=-1) (队列非空则执行
i=cq[f]; f=f+l；//Vi 出队
p=G->adj 1 ist[i].firstedge:〃取 Vi 的边表头指针
while(p) (〃依次搜索Vi的邻接点Vj (令p->adjvex=j)if(!visited[p->adjvex]) (〃若 Vj 未访问过
printf("%c",G->adjlist[p->adjvex].vertex)；〃访问 Vj
〃访问过的Vj入队
visited[p->adj vex] =TRUE ； r=r+1: cq[r]=p->adjvex；}
〃找Vi的下一个邻接点
p=p->next；}
)//cndwhile
)
〃主函数
void main() {int i；
ALGraph *G；G=(ALGraph *)malloc(sizeof(ALGraph))；
CreatALGraph(G)；printf("Print Graph DFS:")；
DFS(G)；printf("\n")；
printf(MPrint Graph BFS: ")；BFS(G3)；
printf(,,\n,,);
}
执行顺序：
Input VertexNum(n) and EdgesNum(e): 8, 9
Input Vertex string: 01234567
图G的示例
Input edges,Creat Adjacency List
0 1
02
1 3
1 4
25
26
37
47
56
Print Graph DFS: 02651473
Prim Graph BFS: 37140265
实验七 电话号码查询系统的设计与实现
一、实验性质：必做二、实验学时:4学时
三、实验类型：综合四、实验目的
利用《数据结构》课程相关知识，以C/C++作为编程语言完成一个具有一定 难度的综合实验。通过本实验，巩固和加深对线性表、栈、队列、树、图、查找、 排序等理论知识的理解；掌握现实问题的分析和解决方法，进而提高利用计算机 分析解决综合实际问题的基本能力。
五、实验内容
编写一个电话号码查询系统，要求按照人名顺序进行记录排序，分别按照电 话号码和人名进行查询，能将满足查询要求的记录删除。
具有要求：
1)
2)
3)
4)
5)
6)
7)
数据以文件的方式存放；
从文件中读取数据；
按照人名对对电话本中的记录进行排序； 根据电话号码查找相关信息；
根据姓名查找相关信息；
删除符合条件的记录；
数据输出以文件存储。

实验一线性表的基本操作
一、实验性质：必做二、实验学时:2学时
三、实验类型：验证四、实验目的
1、掌握用VC++上机调试线性表的基本方法；2、掌握线性表的基本操作，插入、删除、查找，以及线性表合并等运算在顺序存 储结构和链接存储结构上的运算。
五、实验内容
1) 线性表建立、插入、删除操作实现：
2) 己知有序表SA, SB,其元素均为递增有序，将此两表归并成一个新有序 表SC,且SC中的元素仍然递增有序。
六、程序实现struct SQList
{
int eiem[MAXSIZE];
intlen;}；
SQList creat_SQList()/*建立顺序表*/(
SQList 1;
int i=0;
printf(H请输入顺序表”)；
scanf(u%du,&l.elem[i]);
while(Lelem [i]!=0)
{i++；
scanf(n%dM,&Lelem [i]);
}
l.len=—i;
return 1;
void print_SQList(SQList 1)//顺序表输出}
SQList Merge_SQList(SQList LA,SQList LB)/*合并*/(
)
SQList SQList_insert(SQList s,int i,int x)/*插入*/{
intj;
if(i<()||i>s.len)printf("插入位置不存在，
else
(for(j=s.len ;j>=i;j-)
s.elem [j+l]=s.elem [j];s.elem [i]=x;
s.len =s.len+l;
}
//print_SQList( s);
return s;}
SQList SQList_delete(SQList s,int i)/*删除*/(
intj;
if(i<O||i>s.len)printf("i位置不存在，
elsefor(j=i;j<=s.len ;j++)
s.elem [j]=s.elem [j+l];
s.len-;
//prinl_SQList( s); return s;}
void main()(
SQList LA,LB,LC; int i,y,cord;// clrscr();
doprintf(M请输入你的选择(1, 2, 3,
printf("\n
主菜单 \n"）；
printfC'l
建立线性表\n”）；
printf("2
插入一个元素
\n”)；
printf("3
删除一个元素
\n”)；
printf("4
合并线性表
\n”);
printf("5
退出
\nn);
printf(H
\n“);

scanf(”％d”,&c