王道数据结构习题代码2.2.3(线性表)

已于 2022-05-10 23:56:57 修改
阅读量935 收藏
点赞数 1
分类专栏： 考研数据结构模板 # 王道数据结构习题 文章标签： 算法 数据结构 线性回归
于 2022-04-24 23:11:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46503238/article/details/124390586
版权

第一题(c语言)

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;


bool  Del_Min(SqList *L,Elemtype *e)
{

    if(L->len==0)return false;

    *e=L->data[0];
    int pos=0;

    for(int i=0; i<L->len; i++)
    {
        if(L->data[i]<*e)
        {
            *e=L->data[i];
            pos=i;

        }
    }

    L->data[pos]=L->data[L->len-1];
    L->len--;

    return true;
}



int main()
{

    SqList L;
    L.len=0;
    for(int i=0; i<=10; i++)
    {
        L.data[i]=i;
        L.len++;
    }
    L.data[5]=-99;//最小元素


    int k;
    Del_Min(&L,&k);
    printf("%d",k);//-99




    return 0;
}

第二题

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;


bool  Reverse(SqList *L)
{

    if(L->len==0)return false;

    Elemtype t;

    for(int i=0;i<L->len/2;i++)
    {
        //交换变量
        t=L->data[i];
        L->data[i]=L->data[L->len-i-1];
        L->data[L->len-i-1]=t;
    }

    return true;
}

int main()
{

    SqList L;
    L.len=0;
    for(int i=0; i<=10; i++)
    {
        L.data[i]=i;
        L.len++;
    }

   Reverse(&L);

    for(int i=0; i<=10; i++)
    {
      printf("%d ",L.data[i]);//10 9 8 7 6 5 4 3 2 1
    }








    return 0;
}

第三题

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;


void del_x_1(SqList *L,Elemtype e)
{

     int k=0;
    //将不等e的元素挑选出来
    for(int i=0;i<L->len;i++)
    {
        if(L->data[i]!=e)
        {
            L->data[k]=L->data[i];
            k++;
        }
    }
    L->len=k;
}


void del_x_2(SqList *L,Elemtype e)
{
    int k=0;
    //移动思维
    for(int i=0;i<L->len;i++)
    {
        if(L->data[i]==e)k++;
        else{
            L->data[i-k]=L->data[i];//向前移动
        }
    }
    L->len-=k;
}
int main()
{

    SqList L;
    L.len=0;
    for(int i=0; i<=10; i++)
    {
        L.data[i]=i;
        L.len++;
    }
    L.data[2]=-99;
    L.data[3]=-99;
    
    //del_x_1(&L,-99);
    del_x_2(&L,-99);

    for(int i=0; i<L.len; i++)
    {
      printf("%d ",L.data[i]);
    }



    return 0;
}

第四题(双指针)

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

/*顺序表有序*/
bool Del_s_t(SqList *L,int s,int t)
{

    if(L->len==0)return false;

    if(s>=t) return false;

    int i,j;

    //找到大于等于s的第一个值
    for(i=0; i<L->len&&L->data[i]<s; i++);

    if(i>=L->len)return false;
    //找到大于t的第一个值
    for(j=i; j<L->len&&L->data[j]<=t; j++);

    //双指针法(将j后面的元素全部移动到i后面)

    for(; j<L->len; i++,j++)
    {
        L->data[i]=L->data[j];
    }
    L->len=i;

    return true;
}





int main()
{

    SqList L;
    L.len=0;
    for(int i=0; i<10; i++)
    {
        L.data[i]=i+1;
        L.len++;
    }

    Del_s_t_2(&L,2,4);
    for(int i=0; i<L.len; i++)
    {
        printf("%d ",L.data[i]);// 1 5 6 7 8 9
    }




    return 0;
}

第五题

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

bool Del_s_t1(SqList *L,Elemtype s,Elemtype t)
{

    if(L->len==0||s>=t)return false;

    int k=0;

    for(int i=0; i<L->len; i++)
    {
        if(L->data[i]<s||L->data[i]>t)
        {
            L->data[k]=L->data[i];
            k++;
        }
    }
    L->len=k;
    return true;
}


bool Del_s_t2(SqList *L,Elemtype s,Elemtype t)
{
    if(L->len==0||s>=t)return false;

    int k=0;

    for(int i=0; i<L->len; i++)
    {
        if(L->data[i]>=s&&L->data[i]<=t)
        {
            k++;
        }
        else
        {
            L->data[i-k]=L->data[i];
        }
    }
    L->len-=k;

    return true;

}





int main()
{

    SqList L;
    L.len=0;

    for(int i=0; i<10; i++) //10 2 3 4 5 2 1 2 1 3
    {
        scanf("%d",&L.data[i]);
        L.len++;
    }

    //Del_s_t1(&L,2,4);
    Del_s_t2(&L,2,4);

    for(int i=0; i<L.len; i++)
    {
        printf("%d ",L.data[i]);
    }




    return 0;
}

第六题

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

//双指针逐渐像前移动
bool Delete_Same(SqList *L)
{
    if(L->len==0)return false;

    int i,j;
    for(i=0,j=1;j<L->len;j++)
    {
        if(L->data[i]!=L->data[j])
        {
            L->data[++i]=L->data[j];
        }
    }
    L->len=i+1;//下标从0开始所以+1
    return true;
}



int main()
{

    SqList L;
    L.len=0;

    for(int i=0; i<10; i++) //1 2 2 3 3 4 4 5 5 6
    {
        scanf("%d",&L.data[i]);
        L.len++;
    }

    Delete_Same(&L);
    for(int i=0; i<L.len; i++)
    {
        printf("%d ",L.data[i]);
    }




    return 0;
}

第七题(Merge)

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;


bool  Merge(SqList *A,SqList *B,SqList *C)
{
    if(A->len+B->len>maxn)return false; //C的最大长度为100

    int i=0,j=0,k=0;

    while(i<A->len&&j<B->len)
    {
        if(A->data[i]<B->data[j]){
            C->data[k++]=A->data[i++];
        }else{
            C->data[k++]=B->data[j++];
        }
    }

    while(i<A->len){
        C->data[k++]=A->data[i++];
    }
    while(j<B->len){
        C->data[k++]=B->data[j++];
    }
    C->len=k;
    return true;
}



int main()
{

    SqList A,B,C;
    A.len=0,B.len=0,C.len=0;

    for(int i=0; i<10; i++) //1 2 3 4 5 6 7 8 9 10
    {
        scanf("%d",&A.data[i]);
        A.len++;
    }

     for(int i=0; i<10; i++) //1 2 3 4 5 6 7 8 9 10
    {
        scanf("%d",&B.data[i]);
        B.len++;
    }

    Merge(&A,&B,&C);

    for(int i=0; i<C.len; i++)
    {
        printf("%d ",C.data[i]);
    }




    return 0;
}

第八题(数组逆置)

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

typedef int DataType;

void Reverse(DataType A[],int left,int right,int arraySize)
{
    if(left>=right||right>=arraySize)return false;

    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)
{
    Reverse(A,0,m+n-1,arraySize);//整体逆转
    Reverse(A,0,n-1,arraySize);//an......a1逆转
    Reverse(A,n,m+n-1,arraySize);//bn....b1逆转
}

int main()
{

    int a[maxn];

    for(int i=0; i<20; i++) //  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
    {
        scanf("%d",&a[i]);
    }


    Exchange(a,10,10,20);

    for(int i=0; i<20; i++)
    {
        printf("%d ",a[i]);
    }




    return 0;
}

第九题(二分查找)

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

typedef int DataType;


void  SearchExchangeInsert(Elemtype A[],Elemtype e,int len)
{
    int l=0,r=len-1,mid;

    while(l<=r)
    {
        mid=(l+r)/2;
        if(A[mid]==e)break;
        else if(A[mid]<e)
        {
            l=mid+1;
        }
        else
        {
            r=mid-1;
        }
    }
    if(A[mid]==e&&mid!=len-1)
    {
        int t=A[mid];
        A[mid]=A[mid+1];
        A[mid+1]=t;
    }

    if(l>r)
    {
        int i;
        for( i=len-1; i>r; i--)
        {
            A[i+1]=A[i];
        }
        A[i+1]=e;
    }

}
int main()
{

    int a[maxn];

    for(int i=0; i<10; i++) //  1 2 3 4 4 6 7 8 9 10
    {
        scanf("%d",&a[i]);
    }

    SearchExchangeInsert(a,5,10);

    for(int i=0; i<11; i++)
    {
        printf("%d ",a[i]);
    }




    return 0;
}

第十题(2010年真题)数组ab转化为数组ba

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

typedef int DataType;


void Reverse(Elemtype A[],int l,int r)
{
    int mid=(l+r)/2;
    for(int i=0; i<=mid-l; i++)
    {
        Elemtype t=A[l+i];
        A[l+i]=A[r-i];
        A[r-i]=t;
    }
}

void Conserve(Elemtype A[],int p,int n)
{
    Reverse(A,0,n-1);
    Reverse(A,0,n-p-1);
    Reverse(A,n-p,n-1);
}


int main()
{

    int a[maxn];

    for(int i=0; i<10; i++) //  1 2 3 4 5 6 7 8 9 10
    {
        scanf("%d",&a[i]);
    }

    Conserve(a,4,10);

    for(int i=0; i<10; i++)
    {
        printf("%d ",a[i]);
    }




    return 0;
}

第十一题2011年(Merge操作)

第一种时间O(n),空间O(n)

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

typedef int DataType;


void Merge(Elemtype A[],Elemtype B[],Elemtype C[],int len1,int len2)
{

    int i=0,j=0,k=0;

    while(i<len1&&j<len2)
    {
        if(A[i]<=B[j])
        {
            C[k++]=A[i++];
        }
        else
        {
            C[k++]=B[j++];
        }
    }
    while(i<len1)
    {
        C[k++]=A[i++];
    }

    while(j<len2)
    {
        C[k++]=B[j++];
    }

}

Elemtype  FindMiddle(Elemtype A[],Elemtype B[],int len1,int len2)
{
    Elemtype C[len1+len2];
    Merge(A,B,C,len1,len2);


    return C[(len1+len2)/2-1];
}


int main()
{

    int a[maxn];
    int b[maxn];
    for(int i=0; i<5; i++) //  1 3 5 7 9
    {
        scanf("%d",&a[i]);
    }

     for(int i=0; i<5; i++) //  2 4 6 8 10
    {
        scanf("%d",&b[i]);
    }

   printf("%d",FindMiddle(a,b,5,5));


    return 0;
}

第二种复杂度O(n),空间O(1)

根据归并排序思想,并不需要开数组存放,只需要连个指针相互比较即可!

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

typedef int DataType;


Elemtype M_Search(Elemtype A[],Elemtype B[],int len1,int len2)
{

    int i=0,j=0,k=1;

    while(i<len1&&j<len2)
    {   //归并排序,哪一个元素小哪一个元素就上去,然后k++
        if(A[i]<=B[j])
        {
          if(k==((len1+len2)/2))return A[i];
          i++;
        }
        else
        {
           if(k==((len1+len2)/2))return B[j];
           j++;
        }
        k++;
    }
}


int main()
{

    int a[maxn];
    int b[maxn];
    for(int i=0; i<5; i++) //  1 3 5 7 9
    {
        scanf("%d",&a[i]);
    }

    for(int i=0; i<5; i++) //  2 4 6 8 10
    {
        scanf("%d",&b[i]);
    }

    printf("%d",M_Search(a,b,5,5));


    return 0;
}

第十二题2013(抵消思想)

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

typedef int DataType;


Elemtype  Find_MainElem(Elemtype A[],int len)
{
    int count=1, c;
    c=A[0];
    for(int i=1; i<len; i++)
    {
        if(c==A[i])count++;//和主元素相同则++
        else
        {
            if(count>0)count--;//抵消
            else
            {
                count=1;
                c=A[i];//更换新主元素
            }

        }
    }
    count=0;//统计主元素出现次数
    for(int i=0; i<len; i++)
    {
        if(c==A[i])
        {
            count++;
        }
    }
    if(count>len/2)return c;

    return -1;

}


int main()
{

    int a[maxn];
    int b[maxn];
    for(int i=0; i<8; i++) //  0 5 5 3 5 7 5 5  ; 0 5 5 3 5 1 5 7
    {
        scanf("%d",&a[i]);
    }



    printf("%d",Find_MainElem(a,8));


    return 0;
}

第十三题(2018)

最简单的思路就是暴力O(n3)复杂度枚举不同三元组,也可以用散列表O(n)复杂度,空间O(n)

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define maxn 100

typedef int Elemtype;


typedef struct
{
    Elemtype data[maxn];
    int len;
} SqList;

typedef int DataType;


Elemtype  Find_Min(Elemtype A[],int n)
{

    int *vis;
    vis=(int *)malloc(sizeof(int)*n);//分配空间
    
    for(int i=0;i<n;i++)
    {
        vis[i]=0;
    }
    for(int i=0; i<n; i++)
    {
        if(!vis[A[i]]&&A[i]>0)vis[A[i]-1]=1;
    }

    for(int i=0; i<n; i++)
    {
        if(!vis[i])
        {
            return i+1;
        }
    }
    return n+1;
}


int main()
{

    int a[maxn];
    int b[maxn];
    for(int i=0; i<3; i++) //  -5 3 2 3   ; 1 2 3
    {
        scanf("%d",&a[i]);
    }



    printf("%d",Find_Min(a,3));


    return 0;
}

第十四题(2020)

简单分析,距离和S1 S2 S3中最小元素和最大元素的值有关,D=2*(max-min), 由于序列为升序,所以不断向上枚举,将min的值,变大,这样D就越来越小

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>

#define INT_MAX 0x7f7f7f7f

typedef int Elemtype;



int abs_(int a)
{
    if(a<0)return -a;

    return a;
}

bool xls_min(int a,int b,int c) //判断三个数a是否是最小
{
    if(a<=b&&a<=c)return true;
    return false;
}

int findMinnoTrip(int A[],int n,int B[],int m,int C[],int p)
{
    int i=0,j=0,k=0,D_min=INT_MAX,D;

    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_min>D)D_min=D;

        if(xls_min(A[i],B[j],C[k]))
        {
            i++; //将距离缩短
        }
        else if(xls_min(B[j],A[i],C[k]))
        {
            j++;
        }
        else
        {
            k++;
        }

    }
    return D_min;
}
int main()
{

    int a[10];
    int b[10];
    int c[10];
    for(int i=0; i<3; i++) //  -1 0 9
    {
        scanf("%d",&a[i]);
    }

     for(int i=0; i<4; i++) //  -25 -10 10 11
    {
        scanf("%d",&b[i]);
    }

     for(int i=0; i<5; i++) //  2 9 17 30 41
    {
        scanf("%d",&c[i]);
    }




    printf("%d",findMinnoTrip(a,3,b,4,c,5));


    return 0;
}
曼切斯特的流氓
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【代码题 考研数据结构】1-2 线性表--真题
Anthony_4926
11-29 1165
【2019-408】设线性表L=(a1,a2,⋯ ,an−2,an−1,an)L=(a_1, a_2, \cdots, a_{n-2}, a_{n-1},a_n)L=(a1​,a2​,⋯,an−2​,an−1​,an​)采用带头结点的单链表保存，链表中的节点定义如下： typedef struct node{ int data; struct node * next; }NODE; 请设计一个空间复杂度为O(1)O(1)O(1)且时间上尽可能高效的算法，重新排列L中的各结点，得到线性表L′=(a1，.
考研-数据结构-殷人昆.zip
09-09
1.1 针对考研数据结构的代码书写规范以及C 与C 语言基础1 1.1.1 考研综合应用题中算法设计部分的代码书写规范1 1.1.2 考研中的C 与C 语言基础3 1.2 算法的时间复杂度与空间复杂度分析基础 12 1.2.1 考研中的算法时间...
数据结构代码题--线性表
XUN__MLF的博客
08-14 483
考研数据结构代码题，线性表的逆置，三次逆置
数据结构之线性表的应用——完整代码实现
weixin_64618739的博客
11-15 1337
数据结构之线性表的应用——完整代码实现
【C/C++版】王道数据结构代码题——线性表部分持续更新
weixin_44802633的博客
07-04 248
一、顺序表 /* * 2.1 删除最小元素，并用最后一个元素填充 */ void delete_min(sqlList &L, ElemType &e) { //顺序表为空时，输出错误信息 if (L.length == 0) { cout << "error!" << endl; e = -1; return; } /* * min:最小值 * min_i:最
线性表相关代码题--C语言
qq_42338744的博客
07-10 494
单链表以及顺序表的相关代码例题 已验证过 C语言
数据结构英文课件：Chap2 Lists.ppt
06-12
数据结构中的列表是一种重要的逻辑结构，它由相同数据类型的多个数据元素组成，形成有限的序列。在本章中，我们将深入探讨列表的概念、特点以及常见的操作。 2.1 列表的逻辑结构 2.1.1 列表定义：列表是一个包含N...
Redis教程（内含各种数据结构详细的操作命令）
07-17
1、redis概述和安装 1.1、安装redis 1.2、启动redis 1.3、关闭redis 1.4、进入redis命令窗口 1.5、redis命令大全 1.6、redis介绍相关知识 2、redis 5大数据类型 ...2.2.3、数据结构 2.3、redis列表（List）
2.2.3　城市空间结构　课时练习.doc
08-19
2.2.3　城市空间结构　课时练习.doc
quartz-2.2.3-官方文档数据及PDM表结构.zip
06-23
综上所述，"quartz-2.2.3-官方文档数据及PDM表结构.zip"文件包含的内容将帮助开发者深入理解Quartz的各个方面，从基本概念到高级特性，为实际项目中的任务调度提供全面指导。通过学习和应用这些知识，可以提高应用...
2018王道数据结构课后习题代码.rar
09-07
2018王道数据结构课后习题代码
考研王道操作系统重点习题.rar
12-23
这个是汇总的王道操作系统上面的部分易错习题，适合考研的同学，是本人用手机扫描下来的，一道题一道答案，介意勿下。
王道论坛计算机专业考研试题及答案2016
04-09
2016年计算机专业考研试题及答案 5．若森林 F有15 条边、25 个结点，则 F 包含树的个数是 。 A．8 B．9 C．10 D．11 6．下列选项中，不是下图深度优先搜索序列的是 。 、、、
王道考研机试1177题
04-27
王道oj考研上机题，第1177号题源码，c++代码
王道应用题整理
m0_47776000的博客
08-23 1422
王道应用题二、线性表(2.1) 顺序表2.1.1 顺序表查找最小值并返回被删元素的值/*搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置。*/boolDel_Min(sqList &L,int&value){ if(L.length ==0) returnfalse; value = L.data[0]; intpos = 0; for(inti=1;i
19版考研数据结构王道课后习题代码-图【未完】
努力努力再努力0.0的博客
09-18 425
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
王道每日一题2022年考研
qq_44644261的博客
09-25 1095
大家加油！不一定更新 每日一题|计算机考研 20210701 每日一题|计算机考研 20210702 ​​​​​​每日一题|计算机考研 20210703 每日一题|计算机考研 20210704 每日一题|计算机考研 20210705 每日一题|计算机考研 20210706 每日一题|计算机考研 20210707 每日一题|计算机考研 20210708 每日一题|计算机考研 20210709 每日一题|计算机考研20210710 每日一题|计算机考研 20210711 每日一题|计算.
每日一题——王道考研2.2.4.1
弄鹊
03-01 643
2.2.4的第二大题第一小题
【王道2023考研计算机数据结构复习指导课后代码题】——03.合并两个有序顺序表为新的有序顺序表
IronmanJay的博客
06-06 365
将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。
nacos2.2.3
最新发布
08-16
在Nacos的搭建过程中，2.2.3版本是指下载Nacos时选择的版本。根据引用，下载Nacos是搭建集群的一步骤之一。在下载Nacos时，需要指定版本号，比如2.2.3版本。然后根据引用中的配置文件，将Nacos的地址配置为localhost...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值