La->data[i]=rand（）%100;
}
voidPrintList（SequenList*La）//输出数组
{inti;
printf（"thelistdatais:
\n"）;for（i=0;ilength;i++）
printf（"%d",La->data[i]）;
printf（"\n"）;
}
voidOrderList（SequenList*La）//数组选择法排序升序
{inti,j,p,t;
for（i=0;ilength;i++）
{p=i;
for（j=i+1;jlength;j++）
if（La->data[p]>La->data[j]）p=j;
t=La->data[i];La->data[i]=La->data[p];La->data[p]=t;
}
}
voidMergeList（SequenList*La,SequenList*Lb,SequenList*Lc）//合并数组升序
{inti,j,k;
i=0;j=0;k=0;
Lc->length=La->length+Lb->length;
while（ilength&&jlength）
{if（La->data[i]data[j]）
{Lc->data[k]=La->data[i];i++;k++;}
else
{Lc->data[k]=Lb->data[j];j++;k++;}
}
while（ilength）
{Lc->data[k]=La->data[i];i++;k++;}
while（jlength）
{Lc->data[k]=Lb->data[j];j++;k++;}
}
作业21.建立两个递增有序链表带表头用头插法2.输出两个链表合并前的结果。
3.将两个单链表进行合并并保持递增有序。
4.输出合并结果。
#include"malloc.h"
#include"stdio.h"
#include"cstdlib"
typedefintElemType;
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LN;
structLNode*InitList（）;
voidPrintList（structLNode*la）;
voidMergeList（structLNode*la,structLNode*lb,structLNode*lc）;
intmain（intargc,char*argv[]）
{structLNode*head1,*head2,*head3;
head1=InitList（）;
head2=InitList（）;
head3=InitList（）;PrintList（head1）;
PrintList（head2）;
MergeList（head1,head2,head3）;
PrintList（head3）;
return0;
}
structLNode*InitList（）//初始化链表建立链表有表头
{intn,t;
structLNode*lp,*p;
lp=（LNode*）malloc（sizeof（LNode））;
lp->data=0;lp->next=NULL;
printf（"inputlengthoflist:
"）;
scanf（"%d",&n）;
while（n>0）
{printf（"pleaseinputdata:
\n"）;
scanf（"%d",&t）;
p=（LNode*）malloc（sizeof（LNode））;
p->data=t;
p->next=lp->next;
lp->next=p;
n--;
}
returnlp;
}
voidMergeList（structLNode*la,structLNode*lb,structLNode*lc）//合并链表
{structLNode*L1,*L2,*L3;
L1=la->next;L2=lb->next;L3=lc;
la->next=NULL;lb->next=NULL;
while（L1&&L2）
{if（L1->data<=L2->data）
{L3->next=L1;
L3=L1;
L1=L1->next;
}
else
{L3->next=L2;
L3=L2;
L2=L2->next;
}
}
L3->next=L1?
L1:
L2;
}
voidPrintList（structLNode*lp）//输出链表
{structLNode*p;
printf（"thelistdata:
"）;
p=lp->next;while（p）
{printf（"%d",p->data）;
p=p->next;
}
printf（"\n"）;
}
作业3分别用顺序栈和链栈用栈解决括号匹配问题。
1）顺序栈
#include"stdio.h"
#include"malloc.h"
#defineMAX_SIZE100
typedefstruct
{charstack[MAX_SIZE];
inttop;
}SeqStack;
voidInitStack（SeqStack&s）;
voidPush（SeqStack&s,charch）;
voidPop（SeqStack&s）;
intCheck（SeqStack&s）;
charGetTop（SeqStack&s）;
intStackEmpty（SeqStack&s）;
intmain（intargc,char*argv[]）
{SeqStacks;
InitStack（s）;
if（Check（s））
printf（"匹配成功\n"）;
else
printf（"匹配不成功输入有误\n"）;
return0;
}
voidInitStack（SeqStack&s）//初始化栈
{s.top=-1;
}
voidPush（SeqStack&s,charch）//入栈
{if（s.top>=MAX_SIZE-1）
printf（"thestackisoverflow\n"）;
else
{s.top++;
s.stack[s.top]=ch;
}
}
voidPop（SeqStack&s）//出栈
{if（StackEmpty（s））
printf（"thestackisempty\n"）;
else
s.top--;}
intCheck（SeqStack&s）//配对检查
{charch;
while（（ch=getchar（））!
='#'）
{switch（ch）
{case'{':
case'[':
case'（':
Push（s,ch）;break;
case'）':
if（!
StackEmpty（s）&&GetTop（s）=='（'）
{Pop（s）;break;}
elsereturn0;
case']':
if（!
StackEmpty（s）&&GetTop（s）=='['）
{Pop（s）;break;}
elsereturn0;
case'}':
if（!
StackEmpty（s）&&GetTop（s）=='{'）
{Pop（s）;break;}
elsereturn0;
default:
break;
}
}
return（StackEmpty（s））;
}
intStackEmpty（SeqStack&s）//判栈是否为空
{if（s.top==-1）
return1;
else
return0;
}
charGetTop（SeqStack&s）//得到栈顶元素
{if（!
StackEmpty（s））
returns.stack[s.top];
else
{printf（"栈已经为空\n"）;
return0;
}
}
2）链栈
#include"stdio.h"
#include"malloc.h"
typedefstructNode
{chardata;
structNode*next;
}LinkStack;
voidInitStack（LinkStack&s）;
voidPush（LinkStack&s,charch）;
voidPop（LinkStack&s）;intCheck（LinkStack&s）;
charGetTop（LinkStack&s）;
intStackEmpty（LinkStack&s）;
intmain（intargc,char*argv[]）
{LinkStacks;
InitStack（s）;
if（Check（s））
printf（"匹配成功\n"）;
else
printf（"匹配不成功输入有误\n"）;
return0;
}
voidInitStack（LinkStack&s）//初始化栈
{s.next=NULL;
s.data=0;
}
voidPush（LinkStack&s,charch）//入栈
{LinkStack*p;
p=（LinkStack*）malloc（sizeof（LinkStack））;
if（p）
{p->data=ch;
p->next=s.next;
s.next=p;
}
else
{printf（"内存分配失败\n"）;}
}
voidPop（LinkStack&s）//出栈
{LinkStack*p;
if（StackEmpty（s））
{printf（"thestackisempty\n"）;}
else
{p=s.next;
s.next=s.next->next;
free（p）;
}
}
intCheck（LinkStack&s）//配对检查
{charch;
while（（ch=getchar（））!
='#'）
{switch（ch）
{case'{':
case'[':
case'（':
Push（s,ch）;break;
case'）':
if（!
StackEmpty（s）&&GetTop（s）=='（'）
{Pop（s）;break;}elsereturn0;
case']':
if（!
StackEmpty（s）&&GetTop（s）=='['）
{Pop（s）;break;}
elsereturn0;
case'}':
if（!
StackEmpty（s）&&GetTop（s）=='{'）
{Pop（s）;break;}
elsereturn0;
default:
break;
}
}
return（StackEmpty（s））;
}
intStackEmpty（LinkStack&s）//判栈是否为空
{if（s.next）
return0;
else
return1;
}
charGetTop（LinkStack&s）
{if（StackEmpty（s））
{printf（"栈已经为空\n"）;
return0;
}
else
{returns.next->data;}
}
作业41.设计创建二叉树的程序函数名（CreatBitTree）可用递归的方法2.设计二叉树的三种遍历（前序
中序后序）递归的方法
#include"stdio.h"
#include"malloc.h"
typedefstructNode
{chardata;
structNode*Lc,*Rc;
}BTnode,*BTree;//定义二叉树的结点
voidCreatBitTree（BTree&T）;
voidPreorder（BTree&T）;
voidInorder（BTree&T）;
voidPostorder（BTree&T）;
intmain（intargc,char*argv[]）
{BTreeT;
CreatBitTree（T）;
printf（"\n先序遍历\n"）;
Preorder（T）;
printf（"\n中序遍历\n"）;
Inorder（T）;
printf（"\n后序遍历\n"）;Postorder（T）;
printf（"\n"）;
return0;
}
voidCreatBitTree（BTree&T）//创建二叉树先序递归方法
{charch;
scanf（"%c",&ch）;
if（ch=='#'）
T=NULL;
else
{T=（structNode*）malloc（sizeof（structNode））;
if（!
T）
printf（"内存分配失败\n"）;
else
{T->data=ch;
CreatBitTree（T->Lc）;
CreatBitTree（T->Rc）;
}
}
}
voidPreorder（BTree&T）//先序递归遍历二叉树
{if（T）
{printf（"%c",T->data）;
Preorder（T->Lc）;
Preorder（T->Rc）;
}
}
voidInorder（BTree&T）//中序递归遍历二叉树
{if（T）
{Inorder（T->Lc）;
printf（"%c",T->data）;
Inorder（T->Rc）;
}
}
voidPostorder（BTree&T）//后序递归遍历二叉树
{if（T）
{Postorder（T->Lc）;
Postorder（T->Rc）;
printf（"%c",T->data）;
}
}
作业7
1）无向图的邻接矩阵存储深度优先搜索
#include"stdio.h"
#defineMAX_VERTEX_NUM50//顶点的最大数目
intvisited[MAX_VERTEX_NUM];//访问标志数组typedefcharDatatype;
typedefstruct
{Datatypevexs[MAX_VERTEX_NUM];
intedges[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
intn,e;//顶点数和边数
}Ugraph;//无向图
voidCreate_UG（Ugraph&ga）;
voidDFS（Ugraphga）;
voidDFSM（Ugraphga,inti）;
intmain（intargc,char*argv[]）
{Ugraphga;
Create_UG（ga）;
DFS（ga）;
printf（"HelloWorld!
\n"）;
return0;
}
voidCreate_UG（Ugraph&ga）//创建无向图
{inti,j,k,w;
printf（"输入无向图的顶点数和边数:
\n"）;
scanf（"%d%d",&ga.n,&ga.e）;
printf（"请输入顶点信息建立顶点信息表:
\n"）;
getchar（）;
for（i=0;iscanf（"%c",&ga.vexs[i]）;
getchar（）;
for（i=0;ifor（j=0;jga.edges[i][j]=0;
for（k=0;k{printf（"请输入第%d条边的顶点序号ij和权值w:
\n",k+1）;
scanf（"%d%d%d",&i,&j,&w）;
ga.edges[i-1][j-1]=w;
ga.edges[j-1][i-1]=w;
}
}
voidDFS（Ugraphga）//深度优先搜索法遍历无向图
{inti;
for（i=0;ivisited[i]=0;//访问标志数组初始化
for（i=0;iif（!
visited[i]）
DFSM（ga,i）;
}
voidDFSM（Ugraphga,inti）//在邻接矩阵上递归的深度优先遍历图
{intj;
printf（"深度优先遍历结点:
%c\n",ga.vexs[i]）;visited[i]=1;
for（j=0;jif（（ga.edges[i][j]!
=0）&&!
visited[j]）
DFSM（ga,j）;
}
2）无向图的邻接表存储深度优先搜索
#include"stdio.h"
升级会员 