王道第二章线性表习题

最新推荐文章于 2023-07-26 10:16:30 发布
最新推荐文章于 2023-07-26 10:16:30 发布
阅读量163 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43845922/article/details/119388931
版权

P17综合应用题

bool DeleteMin(SqList &L,ElemType &min){
    if(L.length==0){
        printf("顺序表为空\n");
        return false;
    }
    else{
        //先找到最小元素的位置
        min=L.data[0];
        int index=0;//最小元素在数组中的下标
        for(int i=1;i<L.length;i++){
            if(L.data[i]<min){
                min=L.data[i];
                index=i;
            }
        }
        /*
        if(index == L.length-1){//说明这就是最后一个元素
           	L.length--;
            return true;
        }
        else{*/
            L.data[index]=L.data[L.length-1];//将最后一个元素填充过去
            return true;
        //}
    }
}

bool ReverseList(SqList &L){
    if(L.length==0){
        printf("表空\n");
        return false;
    }
    Elemtype t;
    for(int i=0;i<(L.length/2);i++){
        t=L.data[L.length-1-i];
        L.data[L.length-1-i]=L.data[i];
        L.data[i]=t;
    }
 	return true;
}

用k记录顺序表L中不等于x的元素个数(即需要保存的元素的个数)，边扫描L边统计k, 并将不等于x的元素向前移动k个位置，最后修改L的长度

bool DeleteX(SqList &L,Elemtype x){
    if(L.length==0){
        printf("表空\n");
        return false;
    }
    int k=0;
    for(int i=0;i<L.length;i++){
        if(L.data[i] != x){
            L.data[k]=L.data[i];
            k++;
        }
    }
    L.length=k;//@@@
}

这种解法可以不考虑有序表的升序降序问题，但是没有利用有序表的优势

bool DeleteStoT(SqList &L, Elemtype s,Elemtype t){
    if(s>=t || L.length==0){
        printf("Error\n");
        return false;
    }
    int k=0;
    for(int i=0;i<L.length;i++){
        if(!(L.data[i] >= s && L.data[i] <= t)){
            //不符合删除条件的元素则前移k个位置，最后修改L的长度
            L.data[k]=L.data[i];
            k++;
        }
    }
    L.length=k;
    return true;
}

解法2：但是下面的答案默认所给有序表是升序排列的…

bool DeleteStoT(SqList &L, Elemtype s,Elemtype t){
    if(s>=t || L.length==0){
        printf("Error\n");
        return false;
    }
    int i,j;
    for(i=0;i<L.length && L.data[i]<s;i++);//找到第一个>=s的元素的位置
    if(i>=L.length){
        return false;//所有元素均<s;
    }
    for(j=i;j<L.length && L.data[j]<=t;j++);//找到第一个>t的元素的位置
    for(;j<L.length;i++,j++){
        L.data[i]=L.data[j];
    }
    L.length=i;
    return true;
}

bool DeleteStoT(SqList &L, Elemtype s,Elemtype t){
    if(s>=t || L.length==0){
        printf("Error\n");
        return false;
    }
    int k=0;
    for(int i=0;i<L.length;i++){
        if(!(L.data[i] >= s && L.data[i] <= t)){
            //不符合删除条件的元素则前移k个位置，最后修改L的长度
            L.data[k]=L.data[i];
            k++;
        }
    }
    L.length=k;
    return true;
}

bool DeleteSame(SqList &L){
    if(L.length==0){
        printf("Error\n");
        return false;
    }
    int k=0;
    for(int i=1;i<L.length;i++){
        if(L.data[i] != L.data[k])){//若后面的元素不等与前面的元素则加入k中
            L.data[++k]=L.data[i];
        }
    }
    L.length=k+1;//因为k表示数组下标
    return true;
}

bool MergeOrderedList(SqList A,SqList B,SqList &C){
    if(A.length+B.length > C.maxsize){
        return false;
    }
    int i,j,k;
    k=0;
    for(i=0,j=0;i<A.length && j<B.length;){
        if(A.data[i]<B.data[j]){
            C.data[k++]=A.data[i++];
        }else{
            C.data[k++]=B.data[j++];
        }
    }
    while(i<A.length){
        C.data[k++]=A[i++];
    }
    while(j<B.length){
        C.data[k++]=B[j++];
    }
    C.length=k;
    return true;
}

bool ExchangeAB(int A[],int m,int n){
    int i,j;
    i=m-1;
    j=m+n-1;
    int t;
    for(;i>=0;i--,j--){
        t=A[i];
        A[i]=A[j];
        A[j]=t;
    }
    return true;
}

//折半查找
void FindOrInsert(List &L,Elemtype x){
    int low=0,high=L.length-1;
    int mid;
    while(low < high){
        mid=(low+high)/2;
        if(L.data[mid] == x)
            break;
        if(L.data[mid] < x){
            low=mid+1;
        }else{
            high=mid-1;
        }
    }
    
    if(L.data[mid]==x && mid != L.length-1){
    //找到且不是最后一个元素，则和其后面一个元素互换位置
        Elemtype t=L.data[mid+1];
        L.data[mid+1]=L.data[mid];
        L.data[mid]=t;
    }
    if(low > high){
        for(int i=L.length-1; i>high;i--){
            A[i+1]=A[i];
        }
        A[i+1]=x;
        A.length++;
    }
    
}

// My solution   和第8题很像，感觉这种解决方案更优秀
#include<stdio.h>
bool ExchangeAB(int A[],int m,int n){
    int i,j;
    i=m-1;
    j=m+n-1;
    int t;
    for(;i>=0;i--,j--){
        t=A[i];
        A[i]=A[j];
        A[j]=t;
    }
    return true;
}
int main(){
    int a[10]={1,2,3,4,5,6,7,8,9,10};
   ExchangeAB(a,4,6);
    for(int i=0;i<10;i++){
        printf("%d ",a[i]);
    }
}

官方答案

  1. 算法的基本思想，可将这个问题视为把数组ab转换为数组ba(a代表数组的前p个元素，b代表数组中余下的n-p个元素)，先将a逆置，再将b逆置，然后将上面得到的结果整体逆置
  2. 代码
  3. 时间复杂度O(n),空间复杂度O(1)
void Reverse(int R[], int from, int to){
    int i,temp;
    for(i=0;i <(to-from+1)/2;i++){
        temp=R[i+from];
        R[i+from]=R[to-i];
        R[to-i]=temp;
    }

}
void Converse(int R[], int n, int p){
    if(p>=n){
        p=p%n;
    }
    Reverse(R,0,p-1);
    Reverse(R,p,n-2);
    Reverse(R,0,n-1);
}


#include<stdio.h>
int M_Search(int A[],int B[],int n){
	int s1=0,d1=n-1,s2=0,d2=n-1;
	int m1,m2;
	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{//A[m1]>B[m2]
            if((s2+d2)%2==0){
                s2=m2;
                d1=m1;
            }else{
                d1=m1;
                s2=m2+1;
            }
		}
	}
	return A[s1]<B[s2]?A[s1]:B[s2];
}

int main(){
    int a[]={11,13,15,17,19};
    int b[]={2,4,5,8,20};
    int len = sizeof(a)/sizeof(int);
    printf("len = %d\n\n",len);
    int mid = M_Search(a,b,len);
    printf("%d",mid);
    return 0;
}

记主元素的为p
因为候选主元素的个数要大于总数的一半，即 >= n/2+1. 所以如果存在主元素的话它的count一定是>1。分析如下：

  1. 假设总数为偶数个，则候选主元素的count在最坏的情况下是候选主元素均匀分布在数组中，则又因为是总数是偶数个且主元素个数要>= n/2+1，所以最坏情况下必定p在数组中间隔一个分布一个且总有一个位置是有两个连续的p在一起的，所以最坏情况下count也必定大于1 。
  2. 假设总数是奇数个，则最坏情况下m是间隔一个分布一个的，且数组的头尾都是m，所以这种最坏情况下count也必定大于1 。
  3. 综上，可以用count这个巧妙的方法来判断是否有主元素。主要是要注意到要求主元素的个数要大于总数的一半，然后利用这个条件想出来的特征。
    4.当然，主元素必定有count>=1; 但是count>=1却不一定有主元素，所以最后还要统计一下这个count>=1的元素到底有多少个，是否>=n/2+1;
#include<stdio.h>

int MainElement(int A[],int n){
    int e,count=1;
    e=A[0];
    for(int i=0;i<n;i++){
        if(A[i]==e){
            count++;
        }
        else{
            if(count > 0){
                count--;
            }
            else{
                e=A[i];
                count=1;
            }
        }
    }
    if(count > 0){
        count =0;
        for(int i=0;i<n;i++){
            if(A[i]==e){
                count++;
            }
        }
    }
    if(count > n/2 ){
        return e;
    }
    return -1;
}

int main(){
    int a[8]={0,5,5,3,5,7,5,5};
    int b[8]={0,5,5,3,5,1,5,7};
    int maina=MainElement(a,8);
    int mainb=MainElement(b,8);
    printf("maina=%d\n\nmainb=%d\n\n",maina,mainb);
    return 0;
}

数组元素的个数为n, 从1开始排查到n, 如果一旦有没查到的就说明找到了，但是时间复杂度为O(n^2)

#include<stdio.h>

int MinInteger(int A[],int n){
    int i,j;
    for(i=1;i<=n;i++){
        int flag=0;
        for(j=0;j<n;j++){
            if(i == A[j]){
                flag=1;//说明找到与i相同的了
                break;
            }
        }
        if(j==n && flag==0){//如果找到最后一个还没找到和i相同的A[j]，退出循环
            if(i <= n)
                return i;
            else
                return i+1;
        }
    }
}

int main(){
    int a[8]={1,2,3,4,5,6,8,7};
    int b[8]={0,5,5,3,5,1,5,7};
    int x=MinInteger(a,8);
    int y=MinInteger(b,8);
    printf("x=%d\n\ny=%d\n\n",x,y);
    return 0;
}

标准答案
memset函数按字节对内存块进行初始化，所以不能用它将int数组初始化为0和-1之外的其他值（除非该值高字节和低字节相同）
以空间换时间

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int MinInteger(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;
}

int main(){
    int a[8]={1,2,3,4,5,6,8,7};
    int b[8]={0,5,5,3,5,1,5,7};
    int x=MinInteger(a,8);
    int y=MinInteger(b,8);
    printf("x=%d\n\ny=%d\n\n",x,y);
    return 0;
}

暴力求解

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int MinDistance(int A[],int a,int B[],int b,int C[],int c){
    int mins=abs(A[0]-B[0])+abs(A[0]-C[0])+abs(B[0]-C[0]);
    int group[3]={A[0],B[0],C[0]};
    int sum;
    for(int i=0;i<a;i++)
        for(int j=0;j<b;j++)
            for(int k=0;k<c;k++){
                sum=abs(A[i]-B[j])+abs(A[i]-C[k])+abs(C[k]-B[j]);
                if(sum<mins){
                    mins=sum;
                    group[0]=A[i];
                    group[1]=B[j];
                    group[2]=C[k];

                }
            }
    printf("tuple is: ");
    for(int i=0;i<3;i++)
        printf("%d ",group[i]);
    return mins;

}

int main(){
    int S1[3]={-1,0,9};
    int S2[4]={-25,-10,10,11};
    int S3[5]={2,9,17,30,41};
    int d=MinDistance(S1,3,S2,4,S3,5);
    printf("\n");
    printf("%d\n",d);
    return 0;
}

标准答案：
为啥要把最小值的下标+1， 因为如果把非最小值的下标+1，则得到的Distance只会比原来的更大。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
bool isMin(int a,int b,int c){//a是否为最小的那个
    if(a<=b && a<=c)
        return true;
    else
        return false;
}
int MinDistance(int A[],int a,int B[],int b,int C[],int c){

    int group[3]={A[0],B[0],C[0]};
    int i,j,k,d;
    int mind=abs(A[0]-B[0])+abs(A[0]-C[0])+abs(B[0]-C[0]);
    i=j=k=0;
    for(;i<a && j<b && k<c;){
        d=abs(A[i]-B[j])+abs(A[i]-C[k])+abs(B[j]-C[k]);
        if(d < mind){
            mind = d;
            group[0]=A[i];group[1]=B[j];group[2]=C[k];
        }
        if(isMin(A[i],B[j],C[k])){//如果A[i]为三个中最小的
            i++;
        }
        else if(isMin(B[j],C[k],A[i])){
            j++;
        }
        else{
            k++;
        }
    }
    printf("tuple is: ");
    for(int p=0;p<3;p++){
        printf("%d ",group[p]);
    }
    printf("\n");
    return mind;
}

int main(){
    int S1[3]={-1,0,9};
    int S2[4]={-25,-10,10,11};
    int S3[5]={2,9,17,30,41};
    int d=MinDistance(S1,3,S2,4,S3,5);
    printf("\n");
    printf("%d\n",d);
    return 0;
}
为啥不能修改昵称啊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数据结构》第二章线性表习题.doc
12-01
"《数据结构》第二章线性表习题" 本资源摘要信息对应的知识点主要涉及到数据结构的第二章线性表习题，包括线性表的定义、链式存储、顺序存储、单链表、双向循环链表、栈和队列等概念。 一、线性表的定义 线性表是...
第二章线性表习题学生版1
08-03
本章习题主要关注线性表的两种常见实现：顺序表和链表，以及相关操作的时间复杂度和算法设计。 1. 单选题第一题指出，如果线性表中最常用的操作是取第 i 个元素和寻找第 i 个元素的前驱元素，那么采用**顺序表**...
数据结构-王道-线性表
weixin_34375233的博客
09-16 98
目录 线性表-链表 双链表 顺序表和链表的比较 线性表-链表 线性表的链式储存又称为链表，他是指通过一组任意的存储单元来存储线性表中的数据元素。 单链表 typedf struct LNode { ElemType data; struct LN...
数据结构(王道)【线性表】【算法1.1-1.2】
田航语
06-30 689
题目和答案来自数据结构（王道）线性表题目：从顺序表中删除具有最小值元素（假设唯一）并由函数返回被删除元素的值。空出的位置由最后一个元素填补，若顺序表为 空则显示错误信息并退出运行。bool Del_Min(Sqlist &L, ElemType &value){ // 删除顺序表L中最小的元素结点，并通过引用型参数value返回其值 // 如果删除成功，返回true;否则，返回
王道考研2020练习题 第二章 2.3 链表 C++实现
h2809871142的博客
09-01 260
#include "pch.h" #include "iostream" #include "stdio.h" #include "queue" #include "math.h" #include "stack" #include "string" using namespace std; #define ElemType int #define VOID -999999 /* 单链表特点： 它是一种动态的储存结构，链表中每个节点占用的储存空间不是预先分配的，而是运行时系统根据需求生成的 */ ty
王道数据结构线性表课后习题
lisa丶
05-30 2389
1.1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行 。bool Del_Min(SqList &amp;L, ElemType &amp;value) { if (L.length == NULL) return false; value = L.data[0]; //假设0号元素的值最小 i...
数据结构复习—王道课后习题（线性表）
m0_51769031的博客
05-14 2192
一、
第二章线性表王道练习题统考题
qq_41218103的博客
07-22 149
21.（p43）思路： 定义p,q指针，初始时均指向头结点的下一个结点，令p结点向下移动当p节点移动到第k个节点时，q指针开始与p指针一起移动。这样当p指针移动到最后一个是q指针指向倒数第k个节点 int find_font(DLinklist L) { int k=1,count=0; printf("请输入k：\n"); scanf("%d",&k); DLinklist p=L->next,q=L->next; while(p!=NULL) {
王道课后代码第二章线性表
m0_58142184的博客
07-26 161
第二章线性表——王道课后习题代码自用整理，有错误欢迎指正！！
《数据结构》第二章线性表习题.pdf
09-30
《数据结构》第二章线性表习题 本资源是《数据结构》第二章线性表习题，涵盖了线性表的基本概念、顺序表和链表的存储结构、线性表的操作等知识点。 一、线性表的基本概念 线性表是一种有限序列，可以为空或不为空...
《数据结构》第二章线性表习题及参考答案.pdf
10-31
《数据结构》第二章线性表习题及参考答案.pdf
第二章线性表双数题.zip
05-13
在本章中，我们将深入探讨线性表的相关知识点，特别是通过"第二章线性表双数题.zip"这个压缩包中的练习来加深理解。 线性表的常见表示方式有两种：顺序表和链表。顺序表是用一维数组实现的，存储空间连续，元素按...
森林的先序和中序遍历
热门推荐
weixin_43845922的博客
08-02 1万+
森林的先序和中序遍历先序遍历中序遍历最靠谱的方法 先序遍历 中序遍历 最靠谱的方法 把森林转为二叉树，左孩子，右兄弟的那种 然后对二叉树进行先序或中序遍历即得正确结果。
后序线索二叉树
weixin_43845922的博客
08-02 7134
后序线索二叉树后序线索二叉树的构造三叉链表结构PostThreadCreatePostThread后序线索二叉树的遍历FirstnodeNextnode完整测试代码c++测试样例1测试样例2 后序线索二叉树的构造 三叉链表结构 结构体要用三叉链表，因为在遍历中序线索二叉树的时候需要找到某个节点的后继结点，对于右孩子来讲，其后继结点即为它的双亲，所以需要找到其双亲结点，故要用三叉链表 bool CreateThreadTree(ThreadTree &T, ThreadTree parent)树的创
二叉树的递归遍历和销毁c++
weixin_43845922的博客
08-01 3739
二叉树的遍历和销毁 二叉树的建立 二叉树的遍历：前序，中序，后序 二叉树的销毁(后序) #include<stdio.h> #include<stdlib.h> #define ElemType char typedef struct BiTNode{ ElemType data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; void visit(BiTree T,int level){ print
中序线索二叉树
weixin_43845922的博客
08-02 3305
线索二叉树线索二叉树的基本概念中序线索二叉树的构造中序线索二叉树的遍历 线索二叉树的基本概念 中序线索二叉树的构造 中序线索二叉树的遍历
先序线索二叉树
weixin_43845922的博客
08-02 1806
参照 中序线索二叉树 整体思路和中序线索二叉树差不多 只是在先序线索void PreThread(ThreadTree &p,ThreadTree &pre)要注意添加tag的判断，不然可能会出现死循环 if(p->ltag != 1)//@@@ 这里因为p->lchild可能是p的前驱结点，//如果不判断ltag，则会死循环， PreThread(p->lchild,pre);//递归，线索化左子树 if(p->rtag != 1)//@@@
栈的链式存储结构和基本操作
weixin_43845922的博客
07-31 1272
采用链式存储的栈称为链栈，优点是便于多个栈共享存储空间和提高效率，且不存在栈满上溢的情况。通常用单链表实现，并规定所有操作都是在单链表的表头进行的。 这里规定链栈没有头结点。 采用链式存储结构便于结点的插入与删除，链栈的操作和链表类似，入栈和出栈的操作都是链表的表头进行。 //栈的链式存储结构 #include<stdio.h> #include<stdlib.h> typedef struct LSNode{ int data;//数据域 struct LSNod
数据结构第二章线性表
最新发布
10-10
线性表是数据结构中最简单且常用的一种数据结构，它是由同类型的数据元素构成的有序序列。线性表具有以下特点： 1. 元素之间存在顺序关系，即元素在表中的位置是唯一确定的。 2. 线性表中的元素类型可以相同也可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值