1.9有时为了比较两个同数量级算法的优劣,须突出主项的常数因子,而将低次项用大"O"记号表示。
例如,设T1(n)=1.39nlgn+100n+256=1.39nlgn+O(n),T2(n)=2.0nlgn-2n=2.0lgn+O(n),这两个式子表示,当n足够大时T1(n)优于T2(n),因为前者的常数因子小于后者。
请用此方法表示下列函数,并指出当n足够大时,哪一个较优,哪一个较劣?
函数 大"O"表示 优劣
(1)T1(n)=5n2-3n+60lgn 5n2+O(n) 较差
(2)T2(n)=3n2+1000n+3lgn 3n2+O(n) 其次
(3)T3(n)=8n2+3lgn 8n2+O(lgn) 最差
(4)T4(n)=1.5n2+6000nlgn 1.5n2+O(nlgn) 最优
第二章线性表
2.6下述算法的功能是什么?
LinkListDemo(LinkListL){//L是无头结点单链表
ListNode*Q,*P;
if(L&&L->next){
Q=L;L=L->next;P=L;
while(P->next)P=P->next;
P->next=Q;Q->next=NULL;
}
returnL;
}//Demo
答:
该算法的功能是:
将开始结点摘下链接到终端结点之后成为新的终端结点,而原来的第二个结点成为新的开始结点,返回新链表的头指针。
关闭
2.7设线性表的n个结点定义为(a0,a1,...an-1),重写顺序表上实现的插入和删除算法:
InsertList和DeleteList.
解:
算法如下:
#defineListSize100//假定表空间大小为100
typedefintDataType;//假定DataType的类型为int型
typedefstruct{
DataTypedata[ListSize];//向量data用于存放表结点
intlength;//当前的表长度
}Seqlist;
//以上为定义表结构
voidInsertList(Seqlist*L,Datatypex,inti)
{
//将新结点x插入L所指的顺序表的第i个结点ai的位置上,即插入的合法位置为:
0<=i<=L->length
intj;
if(i<0||i>L->length)
Error("positionerror");//非法位置,退出,该函数定义见教材P7.
if(L->length>=ListSize)
Error(“overflow");
for(j=L->length-1;j>=i;j--)
L->data[j+1]=L->data[j];
L->data[i]=x;
L->length++;
}
voidDeleteList(Seqlist*L,inti)
{//从L所指的顺序表中删除第i个结点ai,合法的删除位置为0<=i<=L->length-1
intj;
if(i<0||i>=L->length)
Error("positionerror");
for(j=i;jlength;j++)
L->data[j]=L->data[j+1];//结点前移
L->length--;//表长减小
}
关闭
2.8试分别用顺序表和单链表作为存储结构,实现将线性表(a0,a1,...an-1)就地逆置的操作,所谓"就地"指辅助空间应为O
(1)。
答:
1.顺序表:
要将该表逆置,可以将表中的开始结点与终端结点互换,第二个结点与倒数第二个结点互换,如此反复,就可将整个表逆置了。
算法如下:
//顺序表结构定义同上题
voidReverseList(Seqlist*L)
{
DataTypetemp;//设置临时空间用于存放data
inti;
for(i=0;i<=L->length/2;i++)//L->length/2为整除运算
{temp=L->data;//交换数据
L->data[i]=L->data[L->length-1-i];
L->data[L->length-1-i]=temp;
}
}
2.链表:
分析:
可以用交换数据的方式来达到逆置的目的。
但是由于是单链表,数据的存取不是随机的,因此算法效率太低。
可以利用指针改指来达到表逆置的目的。
具体情况入下:
(1)当链表为空表或只有一个结点时,该链表的逆置链表与原表相同。
(2)当链表含2个以上结点时,可将该链表处理成只含第一结点的带头结点链表和一个无头结点的包含该链表剩余结点的链表。
然后,将该无头结点链表中的所有结点顺着链表指针,由前往后将每个结点依次从无头结点链表中摘下,作为第一个结点插入到带头结点链表中。
这样就可以得到逆置的链表。
算法是这样的:
结点结构定义如下:
typedefcharDataType;//假设结点的数据域类型的字符
typedefstructnode{//结点类型定义
DataTypedata;//结点的数据域
structnode*next;//结点的指针域
}ListNode;
typedefListNode*LinkList;
ListNode*p;
LinkListhead;
LinkListReverseList(LinkListhead)
{//将head所指的单链表(带头结点)逆置
ListNode*p,*q;//设置两个临时指针变量
if(head->next&&head->next->next)
{//当链表不是空表或单结点时
p=head->next;
q=p->next;
p->next=NULL;//将开始结点变成终端结点
while(q)
{//每次循环将后一个结点变成开始结点
p=q;
q=q->next;
p->next=head->next;
head->next=p;
}
returnhead;
}
returnhead;//如是空表或单结点表,直接返回head
}
关闭
2.9设顺序表L是一个递增有序表,试写一算法,将x插入L中,并使L仍是一个有序表。
答:
因已知顺序表L是递增有序表,所以只要从顺序表终端结点(设为i位置元素)开始向前寻找到第一个小于或等于x的元素位置i后插入该位置即可。
在寻找过程中,由于大于x的元素都应放在x之后,所以可边寻找,边后移元素,当找到第一个小于或等于x的元素位置i时,该位置也空出来了。
算法如下:
//顺序表存储结构如题2.7
voidInsertIncreaseList(Seqlist*L,Datatypex)
{
inti;
if(L->length>=ListSize)
Error(“overflow");
for(i=L->length;i>0&&L->data[i-1]>x;i--)
L->data[i]=L->data[i];//比较并移动元素
L->data[i]=x;
L->length++;
}
关闭
2.10设顺序表L是一个递减有序表,试写一算法,将x插入其后仍保持L的有序性。
答:
与上题相类似,只要从终端结点开始往前找到第一个比x大(或相等)的结点数据,在这个位置插入就可以了。
(边寻找,边移动)算法如下:
voidInsertDecreaseList(Seqlist*L,Datatypex)
{
inti;
if(L->length>=ListSize)
Error(“overflow");
for(i=L->length;i>0&&L->data[i-1] L->data[i]=L->data[i];//比较并移动元素
L->data[i]=x;
L->length++;
}
关闭
2.11写一算法在单链表上实现线性表的ListLength(L)运算。
解:
由于在单链表中只给出一个头指针,所以只能用遍历的方法来数单链表中的结点个数了。
算法如下:
intListLength(LinkListL)
{
intlen=0;
ListNode*p;
p=L;//设该表有头结点
while(p->next)
{
p=p->next;
len++;
}
returnlen;
}
关闭
2.12已知L1和L2分别指向两个单链表的头结点,且已知其长度分别为m和n。
试写一算法将这两个链表连接在一起,请分析你的算法的时间复杂度。
解:
分析:
由于要进行的是两单链表的连接,所以应找到放在前面的那张表的表尾结点,再将后表的开始结点链接到前表的终端结点后即可。
该算法的主要时间消耗是用在寻找第一张表的终端尾结点上。
这两张单链表的连接顺序无要求,并且已知两表的表长,则为了提高算法效率,可选表长小的单链表在前的方式连接。
具体算法如下:
LinkListLink(LinkListL1,LinkListL2,intm,intn)
{//将两个单链表连接在一起
ListNode*p,*q,*s;
//s指向短表的头结点,q指向长表的开始结点,回收长表头结点空间
if(m<=n)
{s=L1;q=L2->next;free(L2);}
else{s=L2;q=L1->next;free(L1);}
p=s;
while(p->next)p=p->next;//查找短表终端结点
p->next=q;//将长表的开始结点链接在短表终端结点后
returns;
}
本算法的主要操作时间花费在查找短表的终端结点上,所以本算的法时间复杂度为:
O(min(m,n))
关闭
2.13设A和B是两个单链表,其表中元素递增有序。
试写一算法将A和B归并成一个按元素值递减有序的单链表C,并要求辅助空间为O
(1),请分析算法的时间复杂度。
解:
根据已知条件,A和B是两个递增有序表,所以可以先取A表的表头建立空的C表。
然后同时扫描A表和B表,将两表中最大的结点从对应表中摘下,并作为开始结点插入C表中。
如此反复,直到A表或B表为空。
最后将不为空的A表或B表中的结点依次摘下并作为开始结点插入C表中。
这时,得到的C表就是由A表和B表归并成的一个按元素值递减有序的单链表C。
并且辅助空间为O
(1)。
算法如下:
LinkListMergeSort(LinkListA,LinkListB)
{//归并两个带头结点的递增有序表为一个带头结点递减有序表
ListNode*pa,*pb,*q,*C;
pa=A->next;//pa指向A表开始结点
C=A;C->next=NULL;//取A表的表头建立空的C表
pb=B->next;//pb指向B表开始结点
free(B);//回收B表的头结点空间
while(pa&&pb)
{
if(pb->data<=pa->data)
{//当B中的元素小于等于A中当前元素时,将pa表的开始结点摘下
q=pa;pa=pa->next;
}
else
{//当B中的元素大于A中当前元素时,将pb表的开始结点摘下
q=pb;pb=pb->next;}
q->next=C->next;C->next=q;//将摘下的结点q作为开始结点插入C表
}
//若pa表非空,则处理pa表
while(pa){
q=pa;pa=pa->next;
q->next=C->next;C->next=q;}
//若pb表非空,则处理pb表
while(pb){
q=pb;pa=pb->next;
q->next=C->next;C->next=q;}
return(C);
}
该算法的时间复杂度分析如下:
算法中有三个while循环,其中第二个和第三个循环只执行一个。
每个循环做的工作都是对链表中结点扫描处理。
整个算法完成后,A表和B表中的每个结点都被处理了一遍