作业 线性表练习

线性表练习

1-1对于顺序存储的长度为N的线性表，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。(2分) T

1-2对于顺序存储的长度为N的线性表，删除第一个元素和插入最后一个元素的时间复杂度分别对应为O(1)和O(N)。(2分) F

1-3循环链表不是线性表。 (2分) F

1-3答案正确(2 分)1-4顺序存储的线性表可以随机存取。(2分) T

1-4答案正确(2 分)1-5链式存储的优点是插入、删除元素时不会引起后续元素的移动，缺点是只能顺序访问各元素。 (2分) T

2-1在N个结点的顺序表中，算法的时间复杂度为O(1)的操作是：A (2分)

A.访问第i个结点（1≤i≤N）和求第i个结点的直接前驱（2≤i≤N）
B.在第i个结点后插入一个新结点（1≤i≤N）
C.删除第i个结点（1≤i≤N）
D.将N个结点从小到大排序

2-2若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用哪种存储方式最节省时间？ D (2分)

A.双链表
B.单循环链表
C.带头结点的双循环链表
D.顺序表

2-3下面的叙述正确的是( )。 D (2分)

A.线性表在链式存储时，查找第i个元素的时间同i的值成反比
B.线性表在链式存储时，查找第i个元素的时间同i的值无关
C.线性表在顺序存储时，查找第i个元素的时间同i 的值成正比
D.线性表在顺序存储时，查找第i个元素的时间同i的值无关

2-4设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是： D (2分)

A.h=t; t->next=h->next;
B.t->next=h->next; h=t;
C.h=t; t->next=h;
D.t->next=h; h=t;

2-5带头结点的单链表h为空的判定条件是： B (2分)

A.h == NULL;
B.h->next == NULL;
C.h->next == h;
D.h != NULL;

5-1合并两个排序的整数数组A和B变成一个新的数组。例如，给出A={1,2,3,4}，B={2,4,5,6}，则合并后的数组为 {1,2,2,3,4,4,5,6}。

#include 
#include 
#include 
using namespace std;

class Solution {
public:
    /**
     * @param A and B: sorted integer array A and B.
     * @return: A new sorted integer array
     */
    vector<int> mergeSortedArray(vector<int> &A, vector<int> &B) {
        vector<int> result;
        int lena = A.size();
        int lenb = B.size();
        int ia = 0, ib = 0;
        while (ia < lena && ib < lenb)
        {
            int val_a = A[ia];
            int val_b = B[ib];
            int val;
            if (val_a <= val_b) {val = val_a; ia++;}
            else {val = val_b; ib++;
            result.push_back(val)(4分);
        }
        while (ia < lena)
        {
            result.push_back(A[ia]);
            ia++(3分);
        }
        while (ib<lenb(3分))
        {
            result.push_back(B[ib]);
            ib++;
        }
        return result;
    }
};

5-2下列代码的功能是返回带头结点的单链表L的逆转链表。

List Reverse( List L )
{
    Position Old_head, New_head, Temp;
    New_head = NULL;
    Old_head = L->Next;

    while ( Old_head )  {
        Temp = Old_head->Next;
        Old_head->Next=New_head(3分);  
        New_head = Old_head;  
        Old_head = Temp; 
    }
    L->Next=New_head(3分);
    return L;
}