线性表 08-12年1月试题及参考答案

第2章 线性表08-12年1月试题及参考答案

（2008年1月）

2、在下列对顺序表进行的操作中，算法时间复杂度为O(1)的是（ ）

A、访问第i个元素的前驱（1

B、在第i个元素之后插入一个新元素(1?i?n) C、删除第i个元素(1?i?n) D、对顺序表中元素进行排序

3、假设带头结点的单向循环链表的头指针为head,则该链表为空的判定条件是（ ）

A、head= =NULL B、head–>next= =NULL C、head!=NULL D、head–>next= =head

17、输入线性表的n个元素建立带头结点的单链表，其时间复杂度为___________。

30、假设以带头结点的单链表表示线性表,阅读下列算法f30,并回答问题: (1) 设线性表为( a1, a2, a3, a4, a5, a6, a7 ), 写出执行算法f30后的线性表； (2) 简述算法f30的功能。 void f30(LinkList L) {

//L为带头结点单链表的头指针 LinkList p,q; p=L;

while (p &&p–>next){ q = p–>next;

p–>next =q–>next; p =q–>next; free(q); } }

(1)

(2)

34、假设以单链表表示线性表,单链表的类型定义如下:

typedef struct node { DataType data; struct node *next;

} LinkNode, *LinkList;

编写算法,将一个头指针为head且不带头结点的单链表改造为一个含头结点且头指针仍为head的单向循环链表,并分析算法的时间复杂度。

（2008年10月）

3、在头指针为head的非空单循环链表中，指针p指向尾结点，下列关系成立的是（ ）

A、 p->next==head B、 p->next->next==head C、 p->next==NULL D、 p==head

17、将两个长度分别为m和n的递增有序单链表，归并成一个按元素递减有序的单链表，可能达到的最好的时间复杂度是 。 30、已知线性表的存储结构为顺序表，阅读下列算法，并回答问题： （1）设线性表L=（21，-7，-8，19，0，-11，34，30，-10），写出执行f30(&L)后的L状态；

（2）简述算法f30的功能。 void f30 (SeqList *L) { int i,j;

for (i=j=0;ilength; i++) if(L->data[i]>=0){

if(i!=j)L->data[j]=L->data[i]; j++； }

L->length=j; }

(1) (2)

（2009年1月）

2、假设某个带头结点的单链表的头指针为head，则判定该表为空表的条件是( )

A、head==NULL； B、head->next==NULL； C、head!=NULL； D、head->next==head；

17、在双向循环链表中插入一个新的结点时，应修改_________个指针域的值。 30、假设以带头结点的单链表表示线性表，单链表的类型定义如下： typedef int DataType;

typedef struct node { DataType data; struct node * next; } LinkNode, * LinkList;

阅读下列算法，并回答问题：

(1)已知初始链表如图所示，画出执行f30(head)之后的链表；

题30图

(2)简述算法f30的功能。 void f30( LinkList head) { LinkList p,r, s; if (head - > next)

{

r = head - > next; p = r->next;

r - > next = NULL; while (p) {

s =p;

p = p->next;

if ( s - > data% 2 = = 0) {

s - > next = head - > next; head - > next = s; } else {

s - > next = r - > next;

r->next = s; r =s; } } }

} (1) (2)

34、假设以带头结点的单链表表示线性表，单链表的类型定义如下： typedef int DataType; typedef struct node { DataType data; struct node * next; } LinkNode, * LinkList;

编写算法，删除线性表中最大元素(假设最大值唯一存在)。函数原型为： void f34(LinkList head) ; （2009年10月）

3、指针p、q和r依次指向某循环链表中三个相邻的结点，交换结点*q和结点*r在表中次序的程序段是（ ）

A、p->next=r； q->next=r->next； r->next=q； B、p->next=r； r->next=q； q->next=r->next； C、r->next=q； q->next=r->next； p->next=r； D、r->next=q； p->next=r； q->next=r->next； 17、如果需要对线性表频繁进行________或________操作，则不宜采用顺序存储结构。

31、假设学生成绩按学号增序存储在带头结点的单链表中，类型定义如下：

typedef struct Node {

int id; /*学号*/

int score； /*成绩*/ struct Node *next；

} LNode， *LinkList； 阅读算法f31，并回答问题： (1)设结点结构为

f31(A，B)后A所指的链表；

，成绩链表A和B如图所示，画出执行算法

(2)简述算法f31的功能。

void f31(LinkList A, LinkList B) {

LinkList p, q; p=A->next; q=B->next; while (p && q) {

if (p->idid)

p=p->next;

else if (p->id>q->id)

q=q->next; else {

if (p->score<60) if (q->score<60)

p->score=q->score;

else p->score=60; p=p->next; q=q->next; } }

}

34、假设线性表采用顺序存储结构，其类型定义如下：

#define ListSize 100 typedef struct {

int data[ListSize]; int length;

} SeqList, *Table;

编写算法，将顺序表L中所有值为奇数的元素调整到表的前端。 （2010年1月）

3、将长度为n的单链表连接在长度为m的单链表之后，其算法的时间复杂度为（ ）

A、O(1) B、O(m) C、O(n) D、O(m+n) 4、在带头结点的双向循环链表中插入一个新结点，需要修改的指针域数量是（ ）

A、2个 B、3个 C、4个 D、6个 17、长度为n的线性表采用单链表结构存储时，在等概率情况下查找第i个元素的时间复杂度是_________。

30、已知下列程序，Ls指向带头结点的单链表。 Typedefstruct node { DataType data; struct node * next; } * LinkList;

void f30( LinkList Ls ) { LinkList p, q;

q = Ls->next;

if ( q && q->next ) { Ls->next = q->next; p=q

while ( p->next ) p = p->next; p->next = q;

}

q->next = NULL;

}

请回答下列问题：

(1)当Ls指向的链表如下图所示，请画出执行本函数之后的链表的结果。

(2)请简述算法的功能。 （2010年10月）

2、若对某线性表最常用的操作是在最后一个结点之后插入一个新结点或删除最后一个结点，要使操作时间最少，下列选项中，应选择的存储结构是( ) A、无头结点的单向链表 B、带头结点的单向链表 C、带头结点的双循环链表 D、带头结点的单循环链表 3、若带头结点的单链表的头指针为head，则判断链表是否为空的条件是( )

A、head=NULL B、head->next=NULL C、head!=NULL D、head->next!=head 17、已知链表结点定义如下：

typedef struct node{

char data［16］； struct node *next; } LinkStrNode； 如果每个字符占1个字节，指针占4个字节，则该链表的存储密度是___________。

30、已知线性表(a1,a2,a3，…，an)按顺序存放在数组a中，每个元素均为整数，下列程序的功能是将所有小于0的元素移到全部大于等于0的元素之前。例如，有7个整数的原始序列为(x,x,-x,-x,x,x,-x)，变换后数组中保存的序列是(-x,-x,-x,x,x,x,x)。请在程序处填入合适的内容，使其成为完整的算法。 f30(int a[],int n) { int k,m,temp； m= (1) ；

while (a[m]<0 &&m

m= (2) ； k=m;

while (k

{ while(a[k]>=0&&k

k= (3) ； if(k

{ temp=a[k]； a[k]=a[m]；

a[m]= (4) ； m= (5) ； } } }

(1) (2) (3) (4) (5)

33、设有单链表类型定义如下： typedef struct node {

int data;

struct node *next;

} *LinkList;

阅读下列算法，并回答问题：

void f33(LinkList head, int A, int B) {

LinkList p=NULL;

While (head !=NULL)

{

if (head->data>A&&head->data

p=head;

head=head->next; }

if (p !=NULL)

printf(\

}

(1)已知链表h如下图所示，给出执行f33(h，5，8)之后的输出结果；

(2)简述算法f33的功能。 （2011年1月） 2、将两个各有n个元素的有序表归并成一个有序表，最少的比较次数是（ ）

A、n-1 B、n C、2n-1 D、2n

17、在单链表中某结点后插入一个新结点，需要修改_______________个结点指针域的值。

32、阅读下列程序。

void f32(int A[],int n)

{

int i,j,m=l,t；

for (i=0; i

for (j=0； j

for (j=1; j

if (A[j-1]>A[j]) {

t=A[j-l];

A[j-1]=A[j]； A[j]=t； m=1； }

}

}

回答问题：

已知整型数组A[ ]={34,26,15,89,42}，写出执行函数调用f32(A,5)后的输出结果。 34、假设用带头结点的单循环链表表示线性表，单链表的类型定义如下： typedef struct node { int data;

struct node*next; }LinkNode，*LinkList;

编写程序，求头指针为head的单循环链表中data域值为正整数的结点个数占结点总数的比例，若为空表输出0，并给出所写算法的时间复杂度。函数原型为：

float f34(LinkList head); （2011年10月）

2.在一个长度为n的顺序表中插入一个元素的算法的时间复杂度为（ ） A.O（1） B.Ｏ（log n） C.O（n） D.O（n2）

3.指针p1和p2分别指向两个无头结点的非空单循环链表中的尾结点，要将两个链表链接成一个新的单循环链表，应执行的操作为（ ） A.p1－＞next=p2－＞next;p2－＞next=p1－＞next; B. p2－＞next=p1－＞next;p1－＞next=p2－＞next;

C. p=p2－＞next; p1－＞next=p;p2－＞next=p1－＞next; D. p=p1－＞next; p1－＞next= p2－＞next；p2－＞next=p; 17.在单链表中，除了第1个元素结点外，任一结点的存储位置均由_____________

指示。

30.阅读下列算法，并回答问题：

（1）假设L=（3，7，7，11，20，20，20，51，51），写出执行函数f30（&L）后的L；

（2）简述f30的功能。 void f30(SeqList *L) {//L为非空的有序表 int i=1,k=0;

while(ilength) { if(L->data[i]!=L->data[k]) L->data[++k]=L->data[i]; i++; }

L->length=k+1; } (1) (2)

（2012年1月）

2.某线性表中最常用的操作是在最后一个元素之后插入元素和删除第一个元素，则最节省运算时间的存储结构是（ ） A.单链表 B.双链表 C.仅有头指针的单循环链表 D.仅有尾指针的单循环链表

17.线性表L=(a1,a2,…，an)用数组表示，假定删除表中任一元素的概率相同，则删除一个元素平均需要移动元素的个数是______。 32.阅读下列算法，并回答下列问题：

(1)简述该算法中标号s1所指示的循环语句的功能； (2)简述该算法中标号s2所指示的循环语句的功能。 LinkList Insertmnode(LinkList head，char x，int m) {

LinkNode*p，*q，*s; int i; char ch； p=head->next；

s1：while (p&&p->data!=x)

p=p->next；

if (p==NULL)printf(\； else {

q=p->next；

s2： for(i=1；i<=m；i++)

{

s=(LinkNode *) malloc(sizeof(LinkNode))； scanf(\％c\，&ch)； s->data=ch； p->next=s；

p=s； }

p->next=q； }

return head；

} (1) (2)

34.假设以单链表表示线性表，单链表的类型定义如下：

typedef struct node { DataType data；

Struct node *next； } LinkNode，* LinkList；

编写算法，在一个头指针为head且带头结点的单链表中，删除所有结点数据域值为x的结点。函数原型为：LinkList delnode (LinkList head，DataType x)

第2章 线性表08-12年1月参考答案

（2008年1月）

2、A 3、D 17、O(n)

30、(1) (a2,a4,a6) (2)删除线性表中奇数序号元素 34、

LinkList CreateCircularList(LinkList head) { LinkList p; p=( LinkList)malloc(sizeof(LinkNode)); p->next=head; head=p;

while(p->next) p=p->next; p->next=head;

return head; }

时间复杂度为O(n)。 （2008年10月）

3、A 17、O(m + n) 30、(1) L=(21,19,0,34,30)

(2)删除顺序表中负值元素

（2009年1月）

2、B 17、4 30、

(1) head 2 8 5 7 ^

(2) 调整链表中的结点，将链表中所有值为偶数的结点移动到表的前端。 34、

void f34(LinkList head) { LinkList p,q,u,v; if(head->next==NULL) return; u=head; v=head->next; q=v; p=v->next; while(p) { if(p->data>v->data) { u=q;v=p;

} q=p;

p=p->next;

} u->next=v->next; free(v); } 方法二：

void f34(LinkList head) { LinkList p,max; if(head->next==NULL) return; max=head->next; p=max->next; while(p) { if(p->data>max->data)

max=p; p=p->next;

} p=head; while(p->next!=max)

p=p->next;

p->next=max->next; free(max); }

（2009年10月）

3、A 17、插入、删除 31、 (1) head 1 70 2 38 3 90 4 60 5 60 ^

(2) 对于表A中成绩低于60的学生，如果在表B中也有成绩记录，则将表A中的成绩修改为其在表B中的成绩，但若其在表B中的成绩高于60分，则只改为60分。

34、

void f34(SeqList *L) { int i,j=0,t; for(i=0;ilength;i++)

if(L->data[i]%2) {

}

if(i!=j) {

t= L->data[i];

L->data[i]= L->data[j]; L->data[j]=t; } j++;

}

（2010年1月）

3、B 4、C 30、

17、O(n)

(1) Ls 2 3 4 5 1 ^

(2) 将单链表的首结点（第一个结点）移到表尾（作为最后一个结点）。

（2010年10月）

2、C 3、B 17、4/5 30、(1) 0 (2) m+1 (3) k+1 (4) temp (5) m+1

33、(1) 7 (2)输出链表中最后一个（若存在）大于A小于B的元素的值。 （2011年1月）

2、B 17、2 32、输出结果： 34 26 15 89 26 15 34 42 15 26 34 42 34、

float f34(LinkList head) { LinkNode *p=head->next;

int m=0,n=0; while(p!=head) { m++; if(p->data>0) p=p->next; }

42 89 89

n++;

if(m) return (float)n/m;

else return 0; }

时间复杂度O(n)。 （2011年10月）

2、C 3、D 17、直接前驱结点的指针域 30、(1)L=（3， 7，11， 20，51） (2)删除有序表中的相同数据 （2012年1月）

2、D 17、(n-1)/2

32、(1)查找数据域的值为x的结点 (2)连续插入m个新结点 34、

LinkList delnode (LinkList head，DataType x) {

LinkNode *p=head,*r; while(p->next) if(p->next ->data!=x)

p=p->next;

else {

r=p->next;

p->next=r->next; free(r); }

}

本文来源：https://www.bwwdw.com/article/hnct.html