1.线性表是（ A）。
A.一个有限序列，可以为空
B.一个有限序列，不可以为空
C.一个无限序列，可以为空
D.一个无限序列，不可以为空
2.线性表的基本运算ListInsert(&L,i,e)表示在线性表L中第i个位置上插入一个元素e，若L的长度为n，则i的合法取值是（ B）。
A.1≤i≤n
B.1≤i≤n+1
C.0≤i≤n-1
D.0≤i≤n
3.顺序表具有随机存取特性，指的是（ C）。
A.查找值为x的元素与顺序表中元素个数n无关
B.查找值为x的元素与顺序表中元素个数n有关
C.查找序号为i的元素与顺序表中元素个数n无关
D.查找序号为i的元素与顺序表中元素个数n有关
4.在顺序表中删除一个元素所需要的时间（ A）。
A.与删除元素的位置及顺序表的长度都有关
B.只与删除元素的位置有关
C.与删除任何其他元素所需要的时间相等
D.只与顺序表的长度有关
5.在n（n>1）个运算的顺序表中，算法时间复杂度为O(1)的运算是（ A）。
A.访问第i个元素（2≤i≤n）并求其前驱元素
B.在第i个元素之后插入一个新元素
C.删除第i个元素
D.将这n个元素递增排序
6.关于线性表的顺序存储结构和链式存储结构的描述中，正确的是（ B）。
Ⅰ.线性表的顺序存储结构优于链式存储结构
Ⅱ.顺序存储结构比链式存储结构的存储密度高
Ⅲ.如需要频繁插入和删除元素，最好采用顺序存储结构
Ⅳ.如需要频繁插入和删除元素，最好采用链式存储结构
A.Ⅰ、Ⅱ、Ⅲ
B.Ⅱ、Ⅳ
C.Ⅱ、Ⅲ
D.Ⅲ、Ⅳ
7.在单链表中，增加一个头节点的目的是为了（C ）。
A.使单链表至少有一个节点
B.标识链表中某个重要节点的位置
C.方便插入和删除运算的实现
D.表示单链表是线性表的链式存储结构
8.通过含有n（n≥1）个元素的数组a，采用头插法建立一个单链表L，则L中节点值的次序（B ）。
A.与数组a的元素次序相同
B.与数组a的元素次序相反
C.与数组a的元素次序无关
D.以上都不对
9.某算法在含有n（n≥1）个节点的单链表中查找值为x节点，其时间复杂度是（ D）。
A.
B.O(1)
C.
D.O(n)
10.在长度为n（n≥1）的单链表中删除尾节点的时间复杂度为（C ）。
A.O(1)
B.
C.O(n)
D.
11.关于线性表的正确说法是（D ）。
A.每个元素都有一个前驱和一个后继元素
B.线性表中至少有一个元素
C.表中元素的排序顺序必须是由小到大或由大到小
D.除第一个元素和最后一个元素外，其余每个元素有且仅有一个前驱和一个后继元素
12.以下关于顺序表的叙述中，正确的是（ C）。
A.顺序表可以利用一维数组表示，因此顺序表与一维数组在结构上是一致的，它们可以通用
B.在顺序表中，逻辑上相邻的元素在物理位置上不一定相邻
C.顺序表和一维数组一样，都可以进行随机存取
D.在顺序表中每一个元素的类型不必相同
13.以下属于顺序表的优点是（ C）。
A.插入元素方便
B.删除元素方便
C.存储密度大
D.以上都不对
14.设线性表中有n个元素，以下运算中，（A ）在单链表上实现要比在顺序表上实现效率更高。
A.删除指定位置元素的后一个元素
B.在尾元素的后面插入一个新元素
C.顺序输出前k个元素
D.交换第i个元素和第n-i+1个元素的值（i=1，2，…，n）
15.以下关于单链表的叙述中正确的是（C ）。
Ⅰ.节点除自身信息外还包括指针域，存储密度小于顺序表
Ⅱ.找第i个节点的时间为O(1)
Ⅲ.在插入、删除运算时不必移动节点
A.仅Ⅰ、Ⅱ
B.仅Ⅱ、Ⅲ
C.仅Ⅰ、Ⅲ
D.Ⅰ、Ⅱ、Ⅲ
1 .设计一个算法，查找非空顺序表L中第一个最大的元素，并返回该元素的逻辑序号。
typedef struct
{
int data[MaxSize];
int length;
}SqList;
int max(SqList *L)
{
int maxl=L->data[0];
int i=1,m;
while(ilength)
{
if(maxldata[i])
{
maxl=L->data[i];
m=i;
}
}
return m;
}
2 .对于带头节点的单链表L1，其节点类型为LinkList，指出以下算法的功能。
void fun(LinkList *&L，ElemType x，ElemType y)
{ LinkList *p=L->next;
while (p!=NULL)
{ if (p->data= =x)
p->data=y;
p=p->next;
}
}
解：将链表中值为x的元素换成值为y。
3 .以下算法用于统计带头节点的单链表L中节点值等于给定值x的节点数的算法，其中存在错误，请指出错误的地方并修改为正确的算法。
int count(LinkList *L,ElemType x)
{ int n=0;
while (L! =NULL)
{ L=L->next;
if (L->data= =x) n++;
}
return n;
}
解：
我认为建表时头节点是从一个空表开始的，所以刚开始时L= =NULL，循环不能进行，所以应改为(L->next)!=NULL。
int count(LinkList *L,ElemType x)
{ int n=0;
while ((L->next)!=NULL)
{ L=L->next;
if (L->data= =x) n++;
}
return n;
}
4 .某非空单链表L中所有元素为整数，设计一个算法将所有小于零的节点移到所有大于等于零的节点的前面。
#include
#include
using namespace std;
typedef struct
{
int data[10];
int length;
}SqList;
*void move(SqList &L)
{
int i=0,j=L->length-1;
int temp;
while(i<j)
{
while(i<j&&L->data[j]>=0)
j–;
while(i<j&&L->data[i]<0)
i++;
if(i<j)
{
temp=L->data[i];
L->data[i]=L->data[j];
L->data[j]=temp;
}
}
}
void createlist(SqList *&L,int a[],int n)
{
int i;
L=(SqList *)malloc(sizeof(SqList));
for(i=0;i<n;i++)
L->data[i]=a[i];
L->length=n;
}
void display(SqList *L)
{
int i;
for(i=0;ilength;i++)
cout<data[i]<<" “;
}
int main()
{
int a[10]={-1,0,-1,9,0,2,-4,0,-3,-9};
SqList *L;
createlist(L,a,10);
move(L);
display(L);
return 0;
}
//不太确定，写了全部的程序
*//在定义实参的时候遇到了问题，SqList &L是指针的引用，所以实参应该是指针类型的。
5 .有一个由整数元素构成的非空单链表A，设计一个算法，将其拆分成两个单链表A和B，使得A单链表中含有所有的偶数节点，B单链表中含有所有的奇数节点，且保持原来的相对次序。
想法：1.A重新创建一个节点，B重新创建一个节点
2.保持原来的相对次序，则使用尾插法建表
#include
#include
using namespace std;
typedef struct LNode
{
int data;
struct LNode *next;
}LinkList;
void split(LinkList *&L,LinkList *&L1,LinkList *&L2)
{
LinkList *r=L->next,*t;
L1=(LinkList *)malloc(sizeof(LinkList));
L1->next=NULL;
L2=(LinkList *)malloc(sizeof(LinkList));
L2->next=NULL;
while(r!=NULL)
{
t=r->next;
if((r->data)%2==0)
{
r->next=L1->next;
L1->next=r;
}
else
{
r->next=L2->next;
L2->next=r;
}
r=t;
}
}
void creatlistf(LinkList *&L,int a[],int n)
{
LinkList *s;
int i;
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
for(i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
void display(LinkList *L)
{
LinkList *p=L->next ;
while(p!=NULL)
{
cout<data <<” ";
p=p->next ;
}
cout<<endl;
}
int main()
{
int a[10]={1,2,3,4,5,6,7,8,9,10};
LinkList *L,*L1,*L2;
creatlistf(L,a,10);
split(L,L1,L2);
display(L1);
display(L2);
return 0;
}
//输入数据时采用头插法，所以数据为10，9，8，7，6，5，4，3，2，1.分开链表时也采用头插法，和原来的数据顺序相同。