北科大大数据结构上机题代码.docx
《北科大大数据结构上机题代码.docx》由会员分享，可在线阅读，更多相关《北科大大数据结构上机题代码.docx（48页珍藏版）》请在冰豆网上搜索。
北科大大数据结构上机题代码
《数据结构》上机题（C语言程序）
1．输入数据（设为整型）建立单链表，并求相邻两节点data值之和为最大的第一节点。
例如输入：
264730（0为结束符），建立：
所求结果=4
程序结构：
类型说明；
建表函数：
Creatlist（L）;求值函数：
Adjmax（L）;
main（）
{变量说明；
调用Creatlist（L）建表；调用Adjmax（L）求值；
打印数据；释放链表空间；
Y继续？
N
停止}
上机题1：
#include
#include
typedefintdatatype;//设当前数据元素为整型
typedefstructnode//节点类型
{
datatypedata;//节点的数据域
structnode*next;//节点的后继指针域
}Linknode,*Link;//linknode为节点说明符，link为节点指针说明符
LinkCreatelist（）//创建单链表的算法
{
inta,c;floatb;
LinkH,P,r;//H,P,r分别为表头，新节点和表尾节点指针
H=（Link）malloc（sizeof（Linknode））;//建立头节点
r=H;
do
{
c=（fflush（stdin）,scanf（"%f",&b））;//判断输入的是否是整数
a=（int）b;
if（c!
=1||a!
=b||a>-2^16||a<2^16-1）printf（"非法输入!
请重新输入!
\n"）;
}while（c!
=1||a!
=b||a>-2^16||a<2^16-1）;
while（a!
=0）
{
P=（Link）malloc（sizeof（Linknode））;//申请新节点
P->data=a;//存入数据
r->next=P;//新节点链入表尾
r=P;
do
{
c=（fflush（stdin）,scanf（"%f",&b））;//判断输入的是否是整数
a=（int）b;
if（c!
=1||a!
=b||a>-2^16||a<2^16-1）printf（"非法输入!
请重新输入!
\n"）;
}while（c!
=1||a!
=b||a>-2^16||a<2^16-1）;
}
r->next=NULL;//将尾节点的指针域置空
return（H）;//返回已创建的头节点
}
LinkAdjmax（LinkH）//求链表中相邻两节点data值之和为最大的第一节点的指针的算法
{
Linkp,p1,q;
inti,j;
p=p1=H->next;
if（p1==NULL）return（p1）;//表空返回
q=p->next;
if（q==NULL）return（p1）;//表长=1时返回
i=p->data+q->data;//相邻两节点data值之和
while（q->next）
{
p=q;q=q->next;//取下一对相邻节点的指针
j=p->data+q->data;
if（j>i）
{
p1=p;
i=j;//取和为最大的第一节点指针
}
}
return（p1）;
}
voidmain（）//主函数
{
LinkA,B,p,q;
inta,b;
do
{
printf（"请输入一组整数（以0为结束符，数之间回车）:
\n"）;
p=A=Createlist（）;//创建新链表
B=Adjmax（A）;//求链表中相邻两节点data值之和为最大的第一节点的指针
a=（int）（B->data）;//取第一节点的data值
printf（"第一节点的data值为:
%d\n",a）;
while（p->next）//释放链表空间
{
q=p;
p=p->next;
free（q）;
}
free（p）;
printf（"是否继续输入下一组整数:
是:
1,否:
0\n"）;
scanf（"%d",&b）;
}while（b）;
}
上机题2.实现算术表达式求值程序（栈的运用）。
设操作数：
0，1，2，……，8，9（可扩充）；
运算符：
+，—，*，/，（，），#（#号为结束）。
输入中缀表达式，如：
5+（4—2）*3#，将其转换成后缀表达式：
542—3*+#，
然后计算，本例结果为11。
程序结构：
类型说明；
两套：
Clearstack（S）、Emptystack（S）、Getstop（S）、Push（S）、Pop（S）；
中缀到后缀转换的函数：
Mid-post（E[n]，B[n]）；
后缀表达式求值的函数：
Postcount（B[n]）；
main（）
{变量说明；
输入中缀表达式，存入E[n]；
调用Mid-post（E，B）；
调用Postcount（B）；
打印表达式结果；
Y继续？
N
停止}
上机题2：
#include
#include
#include
typedefstructnode
{
chardata;
structnode*next;
}snode,*slink;
typedefstructnode1
{
intdata;
structnode1*next;
}snode1,*slink1;
voidClearstack（slinks）//置栈空
{
s=NULL;
}
intEmptystack（slinks）//判断栈是否为空
{
if（s==NULL）return
（1）;//栈空返回1
elsereturn（0）;//栈非空返回0
}
charGetstop（slinks）//取栈顶元素
{
if（s!
=NULL）return（s->data）;
return（0）;
}
voidPush（slink*s,charx）//元素x进栈
{
slinkp;
p=（slink）malloc（sizeof（snode））;//生成进栈p节点
p->data=x;//存入新元素
p->next=*s;//p节点作为新的栈顶链入
*s=p;
}
charPop（slink*s）//出栈
{
charx;
slinkp;
if（Emptystack（*s））return（-1）;//栈空，返回-1
else
{
x=（*s）->data;
p=*s;
*s=（*s）->next;
free（p）;
return（x）;//成功
}
}
voidPush1（slink1*s,intx）//元素x进栈
{
slink1p;
p=（slink1）malloc（sizeof（snode1））;//生成进栈p节点
p->data=x;//存入新元素
p->next=*s;//p节点作为新的栈顶链入
*s=p;
}
intPop1（slink1*s）//出栈
{
intx;
slink1p;
if（Emptystack1（*s））return（-1）;//栈空，返回-1
else
{
x=（*s）->data;
p=*s;
*s=（*s）->next;
free（p）;
return（x）;//成功
}
}
intEmptystack1（slink1s）//判断栈是否为空
{
if（s==NULL）return
（1）;//栈空返回1
elsereturn（0）;//栈非空返回0
}
voidClearstack1（slink1s）//置栈空
{
s=NULL;
}
intGetstop1（slink1s）//取栈顶元素
{
if（s!
=NULL）return（s->data）;
return（0）;
}
intPrecede（charx,chary）
{
inta,b;
switch（x）
{
case'#':
//case'（':
case'（':
a=0;break;
case'+':
case'-':
a=1;break;
case'*':
case'/':
a=2;break;
}
switch（y）
{
case'+':
case'-':
b=1;break;
case'*':
case'/':
b=2;break;
//case'（':
case'（':
b=3;break;
}
if（a>=b）return
（1）;
elsereturn（0）;
}
voidMid_post（charE[],charB[]）//中缀表达式B到后缀表达式E的转换
{
inti=0,j=0;
charx;inta;
slinks=NULL;//置空栈
Clearstack（s）;
Push（&s,'#'）;//结束符入栈
do
{
x=B[i++];//扫描当前表达式分量x
switch（x）
{
case'':
break;
case'#':
{
while（!
Emptystack（s））
{
E[j++]='';//栈非空时
E[j++]=Pop（&s）;
}
}break;
case'）':
{
while（Getstop（s）!
='（'）
{
E[j++]='';
E[j++]=Pop（&s）;
}//反复出栈直到遇到'（'
Pop（&s）;//退掉'（'
}break;
case'+':
case'-':
case'*':
case'/':
case'（':
{
while（Precede（Getstop（s）,x））//栈顶运算符（Q1）与x比较
{
E[j++]='';
E[j++]=Pop（&s）;
}
//E[j++]='';
Push（&s,x）;//Q1E[j++]='';
}break;
default:
E[j++]=x;
}
}while（x!
='#'）;
E[j]='\0';
Clearstack（s）;
}
intEcount（charE[]）//后缀表达式求值
{
inti=0,g=0,k=0,d=0,d1,g1;
charx;
intz,a,b;
slink1s=NULL;
while（E[i]!
='#'）
{
x=E[i];
switch（x）
{
case'':
break;
case'+':
b=Pop1（&s）;a=Pop1（&s）;z=a+b;Push1（&s,z）;break;
case'-':
b=Pop1（&s）;a=Pop1（&s）;z=a-b;Push1（&s,z）;break;
case'*':
b=Pop1（&s）;a=Pop1（&s）;z=a*b;Push1（&s,z）;break;
case'/':
b=Pop1（&s）;a=Pop1（&s）;z=a/b;Push1（&s,z）;break;
default:
{
g=0;g1=0;
while（E[i]!
=''）
{
g1=E[i]-'0';
g=g*10+g1;
i++;
}
Push1（&s,g）;
}
}
i++;
}
if（!
Emptystack1（s））return（Getstop1（s））;
Clearstack1（s）;
}
intpd（charB[]）
{inti=0,c,j,k;
c=strlen（B）;
while（B[i]!
='#'）
{
switch（B[i]）
{
case'':
break;
case'0':
case'1':
case'2':
case'3':
case'4':
case'5':
case'6':
case'7':
case'8':
case'9':
{j=i+1;
if（B[j]==''）
{
while（B[j]==''）j++;
switch（B[j]）
{
case'0':
case'1':
case'2':
case'3':
case'4':
case'5':
case'6':
case'7':
case'8':
case'9':
printf（"1非法输入!
请重新输入!
\n"）;return（0）;break;
}
}
}break;
case'+':
case'-':
case'*':
case'/':
{
j=i-1;
while（B[j]==''）j--;
switch（B[j]）
{
case'+':
case'-':
case'*':
case'/':
case'（':
case'#':
printf（"2非法输入!
请重新输入!
\n"）;return（0）;break;
}
k=i+1;
while（B[k]==''）k++;
switch（B[k]）
{
case'+':
case'-':
case'*':
case'/':
case'）':
case'#':
printf（"3非法输入!
请重新输入!
\n"）;return（0）;break;
}
}break;
case'（':
{
j=i-1;
while（B[j]==''）j--;
switch（B[j]）
{
case'0':
case'1':
case'2':
case'3':
case'4':
case'5':
case'6':
case'7':
case'8':
case'9':
case'#':
case'）':
printf（"4非法输入!
请重新输入!
\n"）;return（0）;break;
}
k=i+1;
while（B[k]==''）k++;
switch（B[k]）
{
case'+':
case'-':
case'*':
case'/':
case'#':
printf（"5非法输入!
请重新输入!
\n"）;return（0）;break;
}
}break;
case'）':
{
j=i-1;
while（B[j]==''）j--;
switch（B[j]）
{
case'（':
printf（"6非法输入!
请重新输入!
\n"）;return（0）;break;
}
k=i+1;
while（B[k]==''）k++;
switch（B[k]）
{
case'0':
case'1':
case'2':
case'3':
case'4':
case'5':
case'6':
case'7':
case'8':
case'9':
printf（"7非法输入!
请重新输入!
\n"）;return（0）;break;
}
}break;
case'\0':
break;
default:
printf（"8非法输入!
请重新输入!
\n"）;return（0）;
}
i++;
}
if（B[0]=='#'）
{
printf（"表达式为空!
请重新输入!
\n"）;return（0）;
}
elseif（B[c-1]!
='#'）
{
printf（"9非法输入!
请重新输入!
\n"）;return（0）;
}
}
voidmain（）
{
inta,b,c,d;
charB[100],E[100];
do
{
do
{
printf（"请输入中缀表达式:
\n"）;
B[100]=fflush（stdin）;
gets（B）;
while（B[0]=='\0'）
{
B[100]=fflush（stdin）;
gets（B）;
}
b=pd（B）;
}while（b==0）;
Mid_post（E,B）;
printf（"后缀表达式为:
\n"）;
printf（"%s\n",E）;
a=Ecount（E）;
printf（"结果=%d\n",a）;
printf（"是否继续?
是:
1否:
0\n"）;
scanf（"%d",&c）;
}while（c==1）;
}
上机题3.实现链式队列运算程序（队列的运用）。
程序结构：
类型说明；
Clearqueue（q）、Emptyqueue（q）、Enqueue（q）、Dequeue（q）；
main（）
{变量说明；
}
上机题3：
#include
#include
#include
typedefstructnode
{
chardata;
structnode*next;
}Qnode,*Qlink;
typedefstruct
{
Qnode*front,*rear;
}linkqueue;
voidClearqueue（linkqueue*q）//清空队列
{
q->front->next=NULL;
q->rear=q->front;
}
voidCreatqueue（linkqueue*q）//创建队列
{
q->front=（Qlink）malloc（sizeof（Qnode））;
q->front->next=NULL;
q->rear=q->front;
}
intEmptyqueue（linkqueue*q）//判断队列是否为空
{
if（q->front==q->rear）return
（1）;
elsereturn（0）;
}
voidEnqueue（linkqueue*q,chare）//元素进队
{
Qlinkp;
p=（Qlink）malloc（sizeof（Qnode））;
p->data=e;
p->next=NULL;
q->rear->next=p;
q->rear=p;
}
charDequeue（linkqueue*q）//元素出队
{
Qlinkp;
if（Emptyqueue（q））return（NULL）;
else
{
p=q->front;
q->front=p->next;
free（p）;
return（q->front->data）;
}
}
voidmain（）
{
chara,b;intc;
linkqueueq;
Creatqueue（&q）;
do{
a=getchar（）;
switch（a）
{
case'0':
{
if（Emptyqueue（&q））
{
printf（"队列为空!
\n"）;
printf（"请继续输入!
\n"）;c=1;
}
else
{
b=Dequeue（&q）;
printf（"%c出队\n",b）;
printf（"请继续输入!
\n"）;
}
}break;
case'@':
{
if（Emptyqueue（&q））
{printf（"队列为空!
\n"）;return;}
else
{
printf（"全部元素出队:
\n"）;
while（Emptyqueue（&q）!
=1）
{
b=Dequeue（&q）;
printf（"%c",b）;
}
printf（"\n"）;
return;
}
}break;
case'\n':
break;
default:
{Enqueue（&q,a）;c=1;}break;
}
}while（c）;
}
上机题4．设电文字符集D及各字符出现的概率F如下：
D={a，b，c，d，e，f，g，h}（字符数n=8）
F={5，29，7，8，14，23，3，11}（%）
编写完成下列功能的程序：
①构造关于F的Huffman树；
②求出并打印D总各字符的Huffman编码。
程序结构：
类型说明；
构造Huffman树的函数：
Huffman_tree（H[m+1]）；
求Huffman编码的函数：
Huffman_code（code[n+1]）；
main（）
{变量说明；
输入字符
升级会员 