哈工大线性表部分作业练习Word下载.docx
《哈工大线性表部分作业练习Word下载.docx》由会员分享，可在线阅读，更多相关《哈工大线性表部分作业练习Word下载.docx（20页珍藏版）》请在冰豆网上搜索。
for（q=L.last;
q>
=p;
q--）
//将位置p，p+1，的元素向下移动一个位置
L.elements[q+1]=L.elements[q];
L.last=L.last+1;
L.elements[p]=x;
showlist（L）;
}
voidDelete（positionp,LIST&
if（（p>
L.last）||（p<
positiondoesnotexist"
L.last=L.last-1;
for（q=p;
q<
q++）
{L.elements[q]=L.elements[q+1];
voidLocate（charx,LISTL）
//返回L表中X元素的位置
for（q=0;
{if（L.elements[q]==x）
%c在第%d位\n"
x,q+1）;
intmain（）
inta,p,i=0;
charx,z[100];
LISTL;
MakeNull（L）;
printf（"
输入元素初始化表（20个数以内）\n"
gets（z）;
while（z[i]!
='
\0'
&
20）
{
L.elements[i]=z[i];
i++;
L.last=L.last+1;
L.last=L.last-1;
表如下：
"
showlist（L）;
while（a!
=0）
\n1.插入操作。
\n"
2.删除操作。
3.查询操作。
0退出。
scanf（"
%d"
&
a）;
if（a==1）
{printf（"
输入：
元素位置\n"
getchar（）;
%c%d"
x,&
p）;
Insert（x,p-1,L）;
elseif（a==2）
输入位置\n"
Delete（p-1,L）;
elseif（a==3）
输入查询元素"
%c"
x）;
Locate（x,L）;
时间复杂度分析：
Insert函数：
O（n）
Delete函数：
Locate函数：
2.实现线性表的带表头结点的单链表存储结构，并分析每种基本操作（算法）的时间复杂度。
#include<
typedefchardatatype;
typedefstructnode*pointer;
structnode{
datatypedata;
pointernext;
};
typedefpointerlklist;
lklistcreat（）;
/*建立链表*/
lklistinitlist（）;
/*初始化*/
intlength（lklisthead）;
/*链表长度*/
pointerget（lklisthead,inti）;
/*搜索结点的值*/
intlocate（lklisthead,datatypex）;
/*查找元素位置*/
voidshow（lklisthead）;
/*遍历显示*/
voidinsertlk（lklisthead,datatypex,inti）;
/*插入*/
voiddeletelk（lklisthead,inti）;
/*删除*/
intmain（）/*带表头结点*/
{pointerhead;
inti;
datatypex;
head=creat（）;
cin>
>
i>
x;
show（head）;
cout<
<
endl<
链表长度为:
"
length（head）<
endl;
序号为"
的链表结点地址为:
get（head,i）<
值为"
x<
的链表结点序号为:
locate（head,x）<
deletelk（head,5）;
insertlk（head,'
x'
5）;
return0;
lklistcreat（）
pointerhead,p,rear;
datatypech;
head=initlist（）;
//添加表头
rear=head;
while（cin>
ch,ch!
$'
）
p=newnode;
p->
data=ch;
rear->
next=p;
rear=p;
next=NULL;
returnhead;
lklistinitlist（）
pointerp;
returnp;
intlength（lklisthead）
pointers;
intj=0;
s=head->
next;
while（s!
=NULL）
j++;
s=s->
returnj;
pointerget（lklisthead,inti）
if（i==0）returnhead;
if（i<
0）returnNULL;
p=head->
while（p!
if（j==i）break;
p=p->
intlocate（lklisthead,datatypex）
{j++;
if（p->
data==x）break;
if（p!
=NULL）returnj;
elsereturn-1;
voidshow（lklisthead）
p->
data<
'
'
;
voidinsertlk（lklisthead,datatypex,inti）
pointerp,q;
p=get（head,i-1）;
while（p==NULL）
非法插入位置！
q=newstructnode;
q->
data=x;
next=p->
next=q;
voiddeletelk（lklisthead,inti）
q=get（head,i-1）;
while（q==NULL||q->
next==NULL）
非法输出位置！
return;
p=q->
deletep;
3.实现线性表的不带表头结点的单链表存储结构，并分析每种基本操作（算法）的时间复杂度
rear=head;
inti=0;
if（i==0）
p=head;
Else
rear->
rear=p;
}
4.实现线性表的游标存储结构，并分析每种基本操作（算法）的时间复杂度。
stdlib.h>
#definemaxsize100
typedefstruct{
chardata;
intnext;
}spacestr;
//存储结构定义
spacestrSPACE[maxsize];
typedefintposition,Cursor;
CursorL,M,avail;
spacestrcreate（）;
//建立静态链表
voidInitialize（）;
//可用空间初始化
CursorDeleteNode（）;
//可用空间的分配操作
voidFreeNode（Cursorq）;
//可用空间的回收操作
voidInsert（intx,positionp,spacestrSPACE[]）;
//插入操作
voidDelete（positionp,spacestrSPACE[]）;
//删除操作
intp,x;
Initialize（）;
//可用空间初始化
p=GetNode（）;
//可用空间的分配操作
Insert（x,p,SPACE[]）;
//插入操作
q=newcelltype;
spacestrcreate（SPACE[]）//时间复杂度O（n）
spacestr*head,p,rear;
charch;
head=SPACE;
p=rear;
voidInitialize（）//时间复杂度O（n）
intj;
/*依次链接池中结点*/
for（j=0;
j<
maxsize-1;
j++）
SPACE[j].next=j+1;
/*最后一个结点指针域为空*/
SPACE[j].next=-1;
/*标识线性表*/
avail=0;
CursorDeleteNode（）//从存储池SPACE中删除一个结点,删除的是avail的next所指向的下一个结点时间复杂度O
（1）
Cursorp;
if（SPACE[avail].next==-1）
p=-1;
else
p=SPACE[avail].next;
SPACE[avail].next=SPACE[p].next;
voidFreeNode（Cursorq）//deleteq;
时间复杂度O（n）
SPACE[q].next=SPACE[avail].next;
SPACE[avail].next=q;
}//放回池中
voidInsert（intx,positionp,spacestrSPACE[]）//插入操作时间复杂度O
（1）
q=GetNode（）;
SPACE[q].data=x;
SPACE[q].next=SPACE[p].next;
SPACE[p].next=q;
voidDelete（positionp,spacestrSPACE[]）//删除操作时间复杂度O
（1）
if（SPACE[p].next!
=-1）
q=SPACE[p].next;
SPACE[p].next=SPACE[q].next;
FreeNode（q）;
next!
=NULL;
q=p->
next=q->
deleteq;
（二）栈、队列和串部分
五.算法设计（作业，必须交）
⑴假设以不带头结点的循环链表表示队列，并且只设一个指针指向队尾结点，但不设头指针。
试设计相应的入队和出队的算法。
入队算法：
Voidrudui（Node<
T>
*rear,Tx）
S=newNode<
s->
if（rear==NULL）
{
rear=s;
next=s;
next=reear->
出队算法：
voidchudui（Node<
*rear）
If（rear==NULL）throw”underflow”
s=rear->
if（s==rear）rear=NULL;
elserear->
next=s->
deletes;
⑵设顺序栈S中有2n个元素，从栈顶到栈底的元素依次为a2n，a2n-1，…，a1，要求通过一个循环队列重新排列栈中元素，使得从栈顶到栈底的元素依次为a2n，a2n-2，…，a2，a2n-1，a2n-3，…，a1，请设计算法实现该操作，要求空间复杂度和时间复杂度均为O（n）。
1.将所有元素出栈并入队
2.依次将队列元素出队；
如果是偶数终点，则再入队，如果是奇数结点，则入栈
3.将奇数结点出栈并入队
4.将偶数结点出队并入栈
5.将所有元素出栈并入队
6.将所有元素出队并入栈为所求
⑶设计算法把一个十进制整数转换为二至九进制之间的任一进制数输出。
voidjinzhi（intnum,intr）
Top=-1;
While（num!
0）
K=num%r;
S[++top]=k;
Num=num/r;
While（top!
Cout<
S[top--];
⑷假设一个算术表达式中可以包含三种括号：
圆括号“（”和“）”，方括号“[”和“]”以及花括号“{”和“}”，且这三种括号可按任意的次序嵌套使用。
编写算法判断给定表达式中所含括号是否配对出现。
括号匹配算法：
voidkuo（chara[],intn）
i=0;
flag=1;
While（i<
n&
flag）
If（a[i]=’（‘||a[i]=’[‘||a[i]=’{‘）S[++top]=a[i++];
Else{
Switcha[i]
case‘）’if（top==-1||S[top--]!
=‘（’）flag=0;
break;
case‘]’if（top==-1||S[top--]!
=‘[’）flag=0;
case‘}’if（top==-1||S[top--]!
=‘{’）flag=0;
}i++；
⑸对串的模式匹配KMP算法设计求模式滑动位置的next函数。
（三）多维数组和广义表部分
五．算法设计（作业，必须交）
1．若在矩阵A中存在一个元素ai,j（0≤i≤n-1，0≤j≤m-1），该元素是第i行元素中最小值且又是第j列元素中最大值，则称此元素为该矩阵的一个马鞍点。
假设以二维数组存储矩阵A，试设计一个求该矩阵所有马鞍点的算法，并分析最坏情况下的时间复杂度。
马鞍点算法：
voidandian（inta[][],intm,intn）
n;
d=a[i][0];
k=0;
for（j=1;
j<
m;
j++）
if（a[i][j]<
d）
{d=a[i][j];
k=j;
for（j=0;
if（a[j][k]>
d）break;
if（j==n）cout<
”输出鞍点”<
k<
a[i][k];
算法分析：
时间复杂度为O（mn+n2）.
2．已知两个n×
n的对称矩阵按压缩存储方法存储在一维数组A和B中，编写算法计算对称矩阵的乘积。
矩阵
升级会员 