数据结构复习(三)线性表②

一些用来复习和提高的题,包括选择题、算法设计题、统考真题等,不定期更新

注:代码部分为伪代码

目录

一、选择题

二、算法设计题

三、真题


一、选择题

(1)在一个长度为 n 的顺序表中删除第 i 个元素时(1 <= i <= n)需前移()个元素

A. n                                                                      B. i - 1

C. n - i                                                                  D. n - i + 1

答案:C

(2)在长度为n的非空线性表中实现插入操作,不是动态分配存储的情况下,i 的合法取值范围为()

A. 1<= i <= n                                                       B. 1 <= i <= n + 1

C. 0 <= i <= n - 1                                                 D. 0 <= i <= n

答案:B

二、算法设计题

(1)LA,LB为两个集合A和B,现求一个集合A = A ∪ B(数据结构C语言版(严蔚敏)P20

void union(List &La, List &Lb){
    La_len = ListLengh(La);
    Lb_len = ListLengh(Lb);          //获取长度
    for(i = 1; i <= Lb_length; i++){
        e = GetElem(Lb, i);       //获取Lb中的一个元素
        if(LocateElem(La ,e) == -1){     //判断La中是否有该元素,如果没有,则插入La中
            ListInsert(La, ++La_len, e);
        }
    }
}

(2)已知LA,LB中的数据元素按值非递减排列,合并LA,LB为一个新的线性表LC,且LC中的数据元素仍然非递减有序,如LA  =(3,5,8,11),LB  =(2,6,8,9,11,15,20),则LC  =(2,3,5,6,8,8,9,11,11,15,20)(数据结构C语言版(严蔚敏)P20

void MergeList(List &La, List &Lb, List &Lc){
    initList(Lc);
    i = j = 1;
    k = 0;    //i指La,j指Lb,k指Lc
    La_length = ListLength(La);
    Lb_length = ListLength(Lb);
    while((i < La_length) && (j < Lb_length)){//La,Lb非空
        GetElem(La, i, ei);
        GetElem(La, j, ej);
        if(ei < ej){     //比较哪个大,谁小就将其插入线性表LC
            ListInsert(Lc, ++k, ei);
            i++;
        } else{
            ListInsert(Lc, ++k, ej);
            j++;
        }
    }
    while(i <= La_len){   //La还没插入完
        GetElem(La, i, ei);
        ListInsert(Lc, ++k, ei);
    }
    while(j <= Ln_len){    //Lb还没插入完
        GetElem(Lb, i, ej);
        ListInsert(Lc, ++k, ej);
    }
}

(3)实现顺序表插入算法(数据结构C语言版(严蔚敏)P24

Status ListInsert_Sq(SqList &L, int i, ElemType e){
    if(i < 1 || i > L.length + 1) return ERROR;          //判断插入位置是否合法
    if(L.length >= L.MaxSize){     
        //判断顺序表是否满,此处动态分配,若不能动态分配,直接ERROR
        newbase = (ElemType*)realloc(L.data, 
                                      (L.MaxSize + LISTINCREASEMENT) * sizeof(LNode));
        //LISTINCREASEMENT是每次再分配内存时的大小增量,如一次再分配10个节点长度的内存
        if(!newbase) exit(OVERFLOW);                    //存储分配失败
        L.data= newbase;                                //分配新基址
        L.MaxSize += LISTINCREASEMENT;
        //return ERROR                                  //如果是静态存储分配的话
    }
    q = &(L.data[i-1]);                                 //获取插入位置
    for(p = &(L.data[L.length-1]); p >= q; --p){
        *(p + 1) = * p;                                 //插入位置及之后位置后移
    }
    *q = e;                                             //此处是地址
    ++L.length;
    return OK;
}

(4)实现顺序表删除算法,删除第i个元素(数据结构C语言版(严蔚敏)P24

Status ListDelete_Sq(SqList &L, int i, ElemType &e){
    if((i < 1) || (i > L.length)) return ERROR   //删除位置合法
    p = &(L/elem[i-1]);  //p为被删除的元素的位置
    e = *p;
    q = L.elem + L.length -1;   // q为表尾元素的位置
    for(++p; p <= q; ++p){
        *(p - 1) = *p;
    }
    --L.length;
    return OK;
}

(5)从顺序表中删除具有最小值的元素(唯一),并由函数进行返回,空出的位置由最后一个元素填补,若顺序表为空,则提示错误并退出运行(王道2023数据结构 P18

bool Del_Min(sqList & L, ElemType &e){
    if(L.length == 0){
        return false;
    }
    e = L.data[0]; //初始化最小值为顺序表第一个元素
    int pos = 0; //设置位置指针
    for(int i = 1; i < L.length; i++){
        if(L.data[i] < e){
            e = L.data[i];
            pos = i
        }
    }
    L.data[pos] = L.data[L.length-1]; 用最后一位填充
    L.length--; 减去长度,默认原有的最后一位元素不在顺序表中了,但实际物理存储中仍然在那个位置
    return true;
}

(6)逆置顺序表L,要求算法时间复杂度为O(1)(王道2023数据结构 P18

void Reverse(SqList &L){
    ElemType temp;
    for(i = 0; i < L.length / 2; i++){
        temp = L.data[i];
        L.data[i] = L.data[L.length-i-1];
        L.data[L.length-i-1] = temp;
    }
}

(7)从有序顺序表中删除值在s与t之间的所有元素(s王道2023数据结构 P18

bool Del_s_t(SqList &L, ElemType s, ElemType t){
    int i, j;
    if(s > t || L.length == 0){
        return false;
    }
    for(i = 0; i < L.length && L.data[i] < s; i++){  //寻找大于s的第一个值
        if(i > L.length){
            return false;
        }
    }
    for(j = i; j 

(8)对长度为n的顺序表L,编写一个时间复杂度为O(n)、空间复杂度为O(1)的算法,删除顺序表中值为x的所有节点(王道2023数据结构 P18

void del_x_1(SqList &L, ElemType x){    //直接跳过值为x的值,用不为x的节点进行填充
    int k = 0, i;
    for(i = 0; i < L.length; i++){
        if(L.data[i] != x){
            L.data[k] = L.data[i];
            k++;
        }
    }
    L.length = k;
}

void del_x_2(SqList &L, ElemType x){    //k记录所有值为k的元素
    int k = 0, i = 0;
    while(i < L.length){
        if(L.data[i] == x){
            k++;
        } else{
            L.data[i-k] = L.data[i];
        }
        i++;
    }
    L.length = L.length - k;
}
void del_x_3(SqList &L, ElemType){   //设置头尾指针往中间遍历
    int i = 0;
    int j = L.length - 1;
    int k = 0;       //记录值为x的数量
    while(i < j){    //循环结束条件
        if(L.data[i] == x){
            k++;
            while(L.data[j] == x){  //找到右侧第一个不为x的值
                k++;
                j--;
            }
            L.data[i] = L.data[j];
            i++;
            j--;
        } else{
            i++;
        }
    }
    L.length = L.length - k;
}
//这是我自己写的算法,可能会有错误,欢迎指正

(9)在一维数组A[m+n]中依次存放两个线性表(a1,a2,a3,...,am)个(b1,b2,b3,...bn)。编写一个函数,让数组中两个顺序表位置互换,即(b1,b2,b3...,bn,a1,a2,a3,...am)(王道2023数据结构 P18

typedef int DataType;
void Reverse(DataType A[], int left, int right, int arraySize){
    //逆转从left到right间A中的元素
    if(left >= right || right >= arraySize){
        return;
    }
    int mid = (left + right) / 2;
    for(int i = 0; i <= mid - left; i++){
        DataType temp = A[left + i];
        A[left + i] = A[right - i];
        A[right - i] = temp;
    }
}

void Exchange(DataType A[], int m, int n, int arraySize){
    //先整体逆序,再前n个逆序,后m个再逆序
    Reverse(A, 0, m+n-1, arraySize);
    Reverse(A, 0, n-1, arraySize);
    Reverse(A, n, m+n-1, arraySize);
}

(10)线性表(a1,a2,a3,...an)中元素递增有序且顺序存储到一维数组中,设计一个算法,在较短时间内查找值为x的元素,找到后将其与其后继元素互换位置,若没有找到,则插入该x元素,并保持线性表仍然递增有序(王道2023数据结构 P18

void SearchExchangeInsert(ElemType A[], ElemType x){
    //时间要好,就折半查找,再插入
    int low = 0, high = n - 1, mid;
    while(low <= high){   //折半查找
        mid = (low + high) / 2;
        if(A[mid] == x) break;
        else if(A[mid] < x) low = mid + 1;
        else high = mid - 1;
    }
    if(A[mid] == x && mid != n-1){   //如果最后一个元素与x相等,则不用交换后继
        t = A[mid];
        A[mid] = A[mid+1];
        A[mid+1 = t;
    }
    if(low < high){   //没有该元素,则从high开始后移元素,再插入mid位置一个x
        for(i = n-1; i > high; i--) A[i+1] = A[i];
        A[i+1] = x;
    }
}

三、真题

(1)设将n(n>1)个整数存放到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p(0【2010统考真题】)
1)给出算法的基本设计思想。
2)根据设计思想,采用C或C++或Java语言描述算法,关键之处给出注释。
3)说明你所设计算法的时间复杂度和空间复杂度。

1)        

        u1s1,这个其实和算法设计题第9题类似。从原顺序表变化到现在的顺序表,同样可以先将现有的顺序表逆置,然后前n-p个逆置,后p个再逆置,就得到题中的结果,过程应为:

        Reverse(0, n-1);

        Reverse(0, n-p-1);

        Reverse(n-p, n-1);

        或者先逆置前p个元素,再逆置后n-p个元素,再逆置整个顺序表,效果是一样的

2)

        代码如下:

void Reverse(int R[], int from, int to){
    int i, temp;
    for(i = 0; i < (to - from + 1) / 2; i++){
        temp = R[from+i];
        R[from+i] = R[to-i];
        R[to-i]= temp;
    }
}

void Converse(int R[], int n, int p){
    Reverse(0, n-1);
    Reverse(0, n-p-1);
    Reverse(n-p, n-1);
}

3)

        三个Reverse函数的时间复杂度分别为O(n/2)、O((n-p)/2)、O(p/2),故时间复杂度应为O(n),仅采用了一个temp作为辅助空间,所以空间复杂度为O(1)

另解:

        使用辅助数组来实现,使用一个长度为p的辅助数组存放需要左移的p个元素,再将原数组之后的n-p个元素全部左移,最后将辅助数组中的元素再填充回去即可,时间复杂度也为O(n),但空间复杂度为O(p)

        代码如下:(也是自己写的,可能有错误,欢迎指正)

void Converse_2(int R[], int n, int p){
    int i;
    int t[p];  //定义辅助数组
    for(i = 0; i < p; i++){
        t[i] = R[i];   //存储前p个的值
    }
    for(i = 0; i < n-p; i++){
        R[i] = R[i+p];  //左移后n-p个元素
    } 
    for(i = 0; i < p; i++){
        R[i+n-p] = t[i];  //重新赋值
    }
    
}

 (2)一个长度为L(L ≥ 1)的升序序列S,处在第 [L/2] 个位置的数称为S的中位数。例如,若序列S=(11,13, 15, 17, 19)。则S的中位数是15,两个序列的中位数是含它们所有元素的升序序列的中位数。例如,若S=(2,4,6,8,20),则S和S的中位数是11。现在有两个等长升序序列A和B,试设计一个在时间和空间两方面都尽可能高效的算法,找出两个序列A和B的中位数,要求:(【2011统考真
题】
1)给出算法的基本设计思想。
2)根据设计思想,采用C或C++或Java语言描述算法,关键之处给出注释。
3)说明你所设计算法的时间复杂度和空间复杂度。

1)

        直接合并两个序列再找其中位数固然可行,但显然不是最优解,于是可以考虑中位数的特点,可分如下三种情况进行讨论

        ① 若a = b,则a或b即为所求的中位数,算法结束

        ② 若a < b,则证明所求的中位数肯定在a,b之间,故舍弃A中较小的一半,舍弃B中较大的一半,要求舍去的长度相等

        ③ 若a > b,则证明所求中位数在b、a之间,则与②相反即可

2)代码如下

int M_Search(int A[], int B[], int n){
    int s1=0, d1 = n-1, m1, s2 = 0, d2 = n-1, m2;
    //分别表示A、B中的首位数、末位数和中位数
    while(s1 != d1 || s2 != d2){   //循环找
        m1 = (s1 + d1) / 2;
        m2 = (s2 + d2) / 2;
        if(A[m1] == B[m2])
            return A[m1];
        if(A[m1] < B[m2]){   //情况②
            if((s1 + d1) % 2 == 0){  //若元素个数为奇数
                s1 = m1;
                d2 = m2;
            } else{
                s1 = m1 + 1;
                d2 = m2;
            }
        } else{    //情况③
            if((s2 + d2) % 2 == 0){  //若元素个数为奇数
                d1 = m1;
                s2 = m2;
            } else{
                d1 = m1;
                s2 = m2 + 1;
            }
        }
    }
    return A[s1] < B[s2] ? A[s1] : B[s2];
} 

3)

        时间复杂度为O(log2n),空间复杂度为O(1)

(3)已知一个整数序列A=(a0,a1,···,an-1),其中0<=ain/2(0<=pk【2013统考真题】)
1)给出算法的基本设计思想。代码注释中
2)根据设计思想,采用C或C++或Java语言描述算法,关键之处给出注释
3)说明你所设计算法的时间复杂度和空间复杂度。时间复杂度:O(n);空间复杂度:O(1)。

1)

        算法目标即找到数组中数目超过一半的元素是哪一个,大体流程应该是先标记出一个可能成为主元素的元素,然后判断其是否为主元素。故分为两步

        ① 选取候选的主元素,由于主元素需要超过一半,故平均来说,每两个元素中应该必有一个主元素,故采取如下方法进行选取:依次扫描数组,将遇到的第一个整数记为候选元素,同时计数器记为1,再往后遍历,如果下一个元素与之相等,则计数器加1,如果不相等,则减1,若计数器值为0,则选取下一个元素作为候选元素,从当前位置开始重复上述过过程。在这种选取的情况下,只要一个元素是主元素,则它必会被选中,即使它分布不均匀,当然被选中的元素却未必一定是主元素,所以需要进行第二步的判断。

        ② 再次扫描数组,统计候选主元素出现的次数,如果大于n / 2,则说明它是主元素,否则不是。

2)代码如下

int Majority(int A[], int n){
    int i, c, count = 1;
    c = A[0]
    for(i = 1; i < n; i++){ //第一次遍历整个数组
        if(A[i] != c){
            count--;
        } else{
            count++;
        }
        if(count < 1){
            c = A[i];
            count = 1;
        }
    }
    //计算是否为主元素
    if(count > 0){ // <0代表没有主元素
        for(i = count = 0; i < n; i++){   //第二次遍历整个数组
            if(A[i] == c){
                count++;
            }
        }
    }
    if(count > n / 2) return c;
    else return -1;
}

3)

        时间复杂度为O(n),空间复杂度为O(1)

        此外,如果采用先排序再统计的方法(快排),时间复杂度为O(log2n),先排序再统计,可以在排序后只扫描一次数组即可得出答案,因为每次遇到新的元素,count只需重置即可,若重置前count大于了n / 2,即可直接得到主元素,无需继续遍历。

        算法题只要解答正确,也能拿分,就算此题采用了O(n2)时间复杂度的算法,也能拿个七八分,所以统考无需花费大量时间在优化算法上,容易得不偿失。

(4)给定一个含 n(n≥1)个整数的数组,请设计一个在时间上尽可能高效的算 法,找出数组中未出现的最小正整数。例如,数组{-5, 3, 2, 3}中未出现的最小正整数是 1;数组{1, 2, 3}中未出现的最小正整数是 4。要求:(【2018统考真题】
1)给出算法的基本设计思想。
2)根据设计思想,采用 C 或 C++语言描述算法,关键之处给出注释。
3)说明你所设计算法的时间复杂度和空间复杂度。

1)

        时间上尽量高效,但未对空间做要求,可以定义一个动态分配存储的数组,直接映射原数组中的值,即新数组的下标对应原数组的值,原数组该值存在,则新数组中此处的值大于0,然后遍历新数组得到第一个值等于0的元素的下标即可。

2)代码如下

int findMissMin(int A[], int n){
    int i, *B;
    B = (int*)malloc(sizeof(int) *n);
    memset(B, 0, sizeof(int)*n);
    for(i = 0; i < n; i++){
        if(A[i] > 0 && A[i] < n){
            B[A[i]-1] = 1;
        }
    }
    for(i = 0; i < n; i++){
        if(B[i] == 0) break;
    }
    return i+1;
}

3)

        时间复杂度为O(n),空间复杂度为O(n)

(5)定义三元组(a, b, c)(其中a, b, c均为正数)的距离D=|a-b| + |b-c| + |c-a|。给定三个非空整数集合S1、S2和S3,按升序分别存储在3个数组中。设计一个尽可能高效的算法,计算并输出所有可能的三元组(a, b, c)(a∈S1, b∈S2, c∈S3)中的最小距离。例如S1 = {-1,0,9}, S2 = {-25,-10,10,11},S3 = {2,9,17,30,41},则最小距离为2,相应的三元组为(9,10,9)。要求:(【2020统考真题】
1)给出算法的基本设计思想。
2)根据设计思想,采用 C 或 C++语言描述算法,关键之处给出注释。
3)说明你所设计算法的时间复杂度和空间复杂度。

1)

        观察题目易得当a = b = c时,距离最小

        其余情况,假设a < b < c,不失一般性,如下图所示

数据结构复习(三)线性表②_第1张图片

        L1 = |a - b|

        L2 = |b - c|

        L3 = |c - a|

        D = L1 + L2 + L3 = 2L3,其余情况与之类似,即问题的关键在于最大值和最小值之间的距离,故每次固定c找一个a,或固定a找一个c,使L3 = |c - a|最小即可

        故基本思想为:

        ① 适应Dmin记录最小距离

        ② S1,S2,S3的下标分别为i,j,k,循环遍历三个数组,执行如下操作,直至遍历结束

        a)计算A[i]、B[j]、C[k]的距离D,并与Dmin比较

        b)将A[i]、B[j]、C[k]中最小值的下标加1

        ③ 输出Dmin

2)代码如下

#define INT_MAX 0x7ffffff

int abs(int a){
    return a < 0 ? -a : a;
}

bool xls_min(int a, int b, int c){  //判断a是否为a,b,c中的最小值
    if(a <= b && a <= c) return true;
    return false;
}

int findMinofTrip(int A[], int n, int B[], int m, int C[], int p){
    //n,m,p分别为数组长度
    int i = 0. j = 0, k = 0, D_Min = INT_MAX;
    while(i < n && j < m && k < p && D_min > 0) {
        D = abs(A[i] - B[j]) + abs(A[i] - C[k]) + abs(B[j] - C[k]);  //计算距离
        if(D < D_min) D_min = D;
        if(xls_min(A[i], B[j], C[k])) i++;   //如果a最小
        else if(xls_min(B[j], A[i], C[k])) j++;  //如果b最小
        else k++;  //如果c最小
    }
    return D_min;
}

3)

        时间复杂度为O(n),空间复杂度为O(1)

你可能感兴趣的:(考研复习,数据结构题目,数据结构,链表)