在长度为n的顺序表中的的末尾位置上插入一个元素，其算法时间复杂度为（  ）。

A:O(1)
B:O(n)
C:O(logn）（以2为底）
D:O(nlogn)
答案: O(1)

A:i++
B:j++
C:i–
D:j–
答案: j++

A:free(p); pre->next=p->next;
B:free(p->next);pre->next=p->next;
C:pre->next=p->next; free(p); 
D:p->next=pre->next;free(p);
答案: pre->next=p->next; free(p); 

A:正确
B:错误
答案: 错误
分析：添加头结点的目的是，简化操作，使得在表头和中间位置对链表的操作统一化。不一定是为了存储链表的长度。

A:正确
B:错误
答案: 错误

A:正确
B:错误
答案: 错误
分析：顺序表中，查找第i个元素，时间是常量。

A:正确
B:错误
答案: 错误
分析：首元素没有前驱，尾元素没有后继。

A:正确
B:错误
答案: 错误
分析：两种存储结构各有优缺点。要根据实际问题选择合适的存储结构。

A:正确
B:错误
答案: 错误
分析：前半句正确，后半句错误。
顺序存储中，插入和删除的效率比较低。

A:正确
B:错误
答案: 错误

A:正确
B:错误
答案: 错误
分析：数组本身不能进行插入和删除，因为数组的长度是不可变的。（在某些语言中）

A:正确
B:错误
答案: 正确

A:正确
B:错误
答案: 正确

A:正确
B:错误
答案: 正确

A:正确
B:错误
答案: 正确

A:p->next==NULL
B:p==NULL
C:p->next==L
D:p==L
答案: p->next==L

A:顺序表    
B:双向链表
C:带头结点的双循环链表
D:单循环链表
答案: 顺序表    

A:单链表  
B:仅有头指针的单循环链表 
C:双链表
D:带尾指针的单循环链表
答案: 带尾指针的单循环链表

A:2
B:3
C:4
D:5
答案: 4

A:O(m)
B:O(n)
C:O(m+n)
D:O(m*n)
答案: O(n)

A:1
B:2
C:3
D:4
答案: 2

A:p->prior->next = p->next
B:p->next = p->prior
C:p->prior = p->next
D:p->prior->next = p
答案: p->prior->next = p->next

A:s->next=p->next;p->next=s;  //将s结点插入到p之后t=s->data;s->data=p->data;p->data;   //s结点和p结点的值互换
B:q=p->next;while(q->next!=p)  q=q->next;s->next=p; q->next=s;
C:q=p->next;while(q->next!=p)  q=q->next;q->next=s; s->next=p;
D:在p结点前插入s结点，而且要求在O(1)内，无法实现。
答案: s->next=p->next;p->next=s;  //将s结点插入到p之后t=s->data;s->data=p->data;p->data;   //s结点和p结点的值互换

A:可采用以下算法实现：第一步：先将两个链表各自遍历一遍，统计出两个单链表的长度m和n。假设m>n，k=m-n第二步：长链表先走k步：用指针p从长链表头开始，先走k步，此时p指向长链表的第k+1个结点。第三步：q从短链表头开始，和p一起走。p和q相等时，即为交点；如果p和q不相交，则两个链表不相交。
B:可采用以下算法实现：第一步：用两个指针p和q，分别从两个链表头开始，向后走。第二步：如果两个指针相等，即指向同一个结点，则说明相交，该结点就是交点。
C:可采用以下算法实现：第一步：将两个链表分别逆置。第二步：从头开始，什么时候链表分叉，该分叉的结点就是相交的结点。
D:该问题无法求解。
答案: 可采用以下算法实现：第一步：先将两个链表各自遍历一遍，统计出两个单链表的长度m和n。假设m>n，k=m-n第二步：长链表先走k步：用指针p从长链表头开始，先走k步，此时p指向长链表的第k+1个结点。第三步：q从短链表头开始，和p一起走。p和q相等时，即为交点；如果p和q不相交，则两个链表不相交。

A:采用快慢指针方法。即：第一步：一个指针走的快，每次走2个结点；一个指针走的慢，每次走1个结点。第二步：当快指针到结尾或空时，慢指针所指结点即为中间结点。注：遇到链表结点为奇数或偶数时，需稍加改进即可。
B:第一步：遍历一遍链表，求出其长度n。第二步：再从头开始遍历链表，到n/2处即可。若n为偶数，中间结点则有2个；若n为奇数，则只有1个。需稍加处理。
C:第一步：将链表中的结点依次放入一个数组中，同时记录结点个数；第二步：数组中间位置即为中间结点。
D:无法实现
答案: 采用快慢指针方法。即：第一步：一个指针走的快，每次走2个结点；一个指针走的慢，每次走1个结点。第二步：当快指针到结尾或空时，慢指针所指结点即为中间结点。注：遇到链表结点为奇数或偶数时，需稍加改进即可。

A:第一步：将单链表逆置；第二步：输出单链表中的元素；第三步：将单链表逆置，即恢复之前的单链表。
B:第一步：将单链表中的 元素依次放入一个数组中第二步：逆序输出该数组中的元素。
C:可用如下代码实现：void reversePrint(Node *p//p初值为单链表第一个结点{       while(p!=NULL)      {  reversePrint(p->next);         printf(“%c  “，p->data);  //假设结点值为字符}
D:算法思想：第一步：从头到尾找到最后一个结点；第二步：从最后一个结点向前依次输出每个结点的值。
答案: 算法思想：第一步：从头到尾找到最后一个结点；第二步：从最后一个结点向前依次输出每个结点的值。

A:正确
B:错误
答案: 错误
分析：静态链表本质仍然是链表，所以它不具有顺序表的优点。

A:正确
B:错误
答案: 错误
分析：前驱和后继是元素间的逻辑关系。
循环单链表是元素的存储关系，只是为了操作方便而采用循环链表，并不会改变元素的逻辑关系。