数据结构 上机测试题 汇总

最新推荐文章于 2024-08-10 18:21:29 发布
最新推荐文章于 2024-08-10 18:21:29 发布
阅读量7.1k 收藏 64
点赞数 10
分类专栏： =======数据结构======= 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L954688947/article/details/50320905
版权
这篇博客汇总了多项数据结构上机测试题目，涉及链表的合并、逆置、差集操作，双链表插入，括号匹配，二叉树的各种遍历，字符串匹配和删除，以及多种排序算法的实现。
摘要由CSDN通过智能技术生成

1、 编写算法，将二个升序链表在原表空间内归并成一个升序链表。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <queue>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct linklist
{
    int data;
    struct linklist *next;
}linklist;

linklist *creat()
{
    linklist *head;
    head=(linklist*)malloc(sizeof(linklist));
    linklist *p,*q=head;
    int temp;
    while(1)
    {
        scanf("%d",&temp);
        if(temp!=-9999)
        {
            p=(linklist*)malloc(sizeof(linklist));
            p->data=temp;
            q->next=p;
            q=p;
        }
        else
        {
            q->next=NULL;
            break;
        }
    }
    return head;
}

linklist* unionlist(linklist* &a,linklist* b)
{
    linklist *pa=a->next,*pb=b->next,*s,*r=a;
    while(pa!=NULL&&pb!=NULL)
    {
        if(pa->data<pb->data)
        {
            r=pa;
            pa=pa->next;
        }
        else
        {
            s=(linklist*)malloc(sizeof(linklist));
            s->data=pb->data;
            s->next=pa;
            r->next=s;
            r=s;
            pb=pb->next;
        }
    }
    if(pb!=NULL)
    {
        r->next=pb;
    }
    return a;
}



int main()
{
    linklist *a,*b,*p;
    printf("input first linklist:");
    a=creat();
    printf("input second linklist:");
    b=creat();
    unionlist(a,b);
    p=a->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    return 0;
}

2、 编写算法，将二个升序链表在原表空间内归并成一个降序链表。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct linklist
{
    int data;
    struct linklist *next;
}linklist;

linklist *creat()
{
    linklist *head;
    head=(linklist*)malloc(sizeof(linklist));
    linklist *p,*q=head;
    int temp;
    while(1)
    {
        scanf("%d",&temp);
        if(temp!=-9999)
        {
            p=(linklist*)malloc(sizeof(linklist));
            p->data=temp;
            q->next=p;
            q=p;
        }
        else
        {
            q->next=NULL;
            break;
        }
    }
    return head;
}

linklist* unionlist(linklist* &a,linklist* b)
{
    linklist *pa=a->next,*pb=b->next,*r=a,*s;
    while(pa!=NULL&&pb!=NULL)
    {
        if(pa->data<pb->data)
        {
            r=pa;
            pa=pa->next;
        }
        else
        {
            s=(linklist*)malloc(sizeof(linklist));
            s->data=pb->data;
            s->next=pa;
            r->next=s;
            r=s;
            pb=pb->next;

        }
    }
    if(pb!=NULL)
    {
        r->next=pb;
    }
    return a;
}

void reverse_link(linklist* &a)
{
    linklist *p=a->next,*q;
    a->next=NULL;
    while(p)
    {
        q=p->next;
        p->next=a->next;
        a->next=p;
        p=q;
    }

}


int main()
{
    linklist *a,*b,*p;
    printf("input first linklist:");
    a=creat();
    printf("input second linklist:");
    b=creat();
    unionlist(a,b);
    reverse_link(a);
    p=a->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    return 0;
}

3、 编写算法，用顺序存储结构实现二个升序集合的A=A－B运算。
（事实上是求集合的差集，即只在A出现，不在B出现的A的元素）

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;
#define maxsize 20

typedef struct sqlist
{
    int data[maxsize];
    int length;
}sqlist,*lnode;

void create(lnode &l,int a[],int n)
{
    l=(sqlist*)malloc(sizeof(sqlist));
    for(int i=0;i<n;i++)
    {
        l->data[i]=a[i];
    }
    l->length=n;
}

void del(lnode &l,int n)
{
    int i;
    for(i=n;i<l->length-1;i++)
    {
        l->data[i]=l->data[i+1];
    }
    l->length--;
}

void listminus(lnode &a,lnode b)
{
    int m=a->length,n=b->length;
    int i,j,k=0;
    for(i=0;i<m;i++)
    {
        for(j=k;j<=n;j++)
        {
            if(a->data[i]==b->data[j])
            {
                del(a,i);
                k=j+1;
            }
        }
    }
}

void show(lnode l)
{
    int i;
    for(i=0;i<l->length;i++)
        printf("%d ",l->data[i]);
}



int main()
{
    lnode A,B;
    int a[10],b[10];
    printf("the five number :");
    for(int i=0;i<5;i++)
    {
        scanf("%d",&a[i]);
    }
    printf("the five number :");
    for(int i=0;i<5;i++)
    {
        scanf("%d",&b[i]);
    }
    create(A,a,5);
    create(B,b,5);
    listminus(A,B);
    show(A);
    return 0;
}

4、 编写算法，用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递减有序。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct node
{
    int data;
    struct node *next;
}node,*linklist;

void create(linklist l)
{
    int e;
    linklist p,q;
    p=l;
    printf("input the list:");
    scanf("%d",&e);
    while(e!=-9999)
    {
        q=(node*)malloc(sizeof(node));
        q->data=e;
        p->next=q;
        q->next=NULL;
        p=q;
        scanf("%d",&e);
    }
}

linklist linkminus(linklist &a,linklist b)
{
    linklist p=a->next,q=b->next,pre=a,r;
    while(p && q)
    {
        if(p->data<q->data)
        {
            pre=p;
            p=p->next;
        }
        else if(p->data>q->data)
        {
            q=q->next;
        }
        else
        {
            pre->next=p->next;
            r=p;
            p=p->next;
            free(r);
        }
    }
    return a;
}

void putdata(linklist l)
{
    linklist p=l->next;
    printf("\n");
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }

}

void reverse_link(linklist &a)
{
    linklist p=a->next,q;
    a->next=NULL;
    while(p)
    {
        q=p->next;
        p->next=a->next;
        a->next=p;
        p=q;
    }
}

int main()
{
    linklist A,B,C;
    A=(node*)malloc(sizeof(node));
    A->next=NULL;
    B=(node*)malloc(sizeof(node));
    B->next=NULL;
    create(A);
    create(B);
    C=linkminus(A,B);
    reverse_link(C);
    putdata(C);
    return 0;
}

5、 编写算法，将一单链表就地逆置。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct linklist
{
    int data;
    struct linklist *next;
}linklist;

linklist* creat()
{
    linklist* head;
    head=(linklist*)malloc(sizeof(linklist));
    linklist *p,*q=head;
    int temp;
    while(1)
    {
        scanf("%d",&temp);
        if(temp!=-9999)
        {
            p=(linklist*)malloc(sizeof(linklist));
            p->data=temp;
            q->next=p;
            q=p;
            p=p->next;
        }
        else
        {
            q->next=NULL;
            break;
        }
    }
    return head;
}

void reverse_link(linklist* &a)
{
    linklist *p=a->next,*q;
    a->next=NULL;
    while(p)
    {
        q=p->next;
        p->next=a->next;
        a->next=p;
        p=q;
    }
}

int main()
{
    linklist *a,*p;
    printf("input first linklist:");
    a=creat();
    p=a->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
    reverse_link(a);
    p=a->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;

    }
    return 0;
}

6、 编写算法，在一个双链表的第i个元素前插入一个元素。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
using namespace std;

typedef struct lnode
{
    int data;
    struct lnode *llink,*rlink;
}lnode,*linknode;

typedef struct
{
    linknode head,rear;
    int len;
}linklist;

void init(linklist &l)
{
    l.head=l.rear=(lnode*)malloc(sizeof(lnode));
    l.len=0;
    l.head->llink=l.head->rlink=l.head;
}

void create(linklist &l)
{
    linknode p;
    int e;
    init(l);
    scanf("%d",&e);
    while(e!=-9999)
    {
        p=(lnode*)malloc(sizeof(lnode));
        p->data=e;
        p->rlink=l.head->rlink;
        l.head->rlink=p;
        p->llink=l.head;
        p->rlink->llink=p;
        if(l.head==l.rear)
        {
            l.rear=p;
        }
        l.len++;
        scanf("%d",&e);
    }
}

int ins(linklist &l,int k,int e)
{
    int j;
    linknode p,q;
    if(k<1||k>l.len)return 0;
    p=l.head;
    j=0;
    while(j<k-1)
    {
        p=p->rlink;
        j++;
    }
    q=(lnode*)malloc(sizeof(lnode));
    q->data=e;
    q->llink=p;
    q->rlink=p->rlink;
    p->rlink=q;
    if(k == ++l.len)
    {
        l.rear=q;
    }
    return 1;
}

void putdata(linklist l)
{
    linknode p = l.head->rlink;
    printf("\n");
    while (p != l.head)
    {
        printf("%d,", p->data);
        p = p->rlink;
    }
}

int main()
{
    linklist l;
    int e;
    printf("\ninput to l:");
    create(l);
    putdata(l);
    ins(l,3,100);
    putdata(l);
    return 0;
}

7、 编写算法，删除一升序单链表中所有值相同的多余元素，释放被删结点空间。

#include <stdio.h
最低0.47元/天 解锁文章
数据结构上机测试题超全合集【C语言描述算法】(完整可编译代码，含运行结果截图)
lei20172017的博客
06-21 5840
1、 编写算法，将二个升序链表在原表空间内归并成一个升序链表。 /* 1、 编写算法，将二个升序链表在原表空间内归并成一个升序链表。*/ #include <stdio.h> #include <stdlib.h> #define MaxSize 50 typedef int ElementType; typedef struct LNode { ElementType data; struct LNode *Next; } LNode,*List;
_DataStructure_C_Impl:求图G中从顶点u到顶点v的一条简单路径
weixin_30656145的博客
08-12 515
#pragma once #include<stdio.h> #include<stdlib.h> #define StackSize 100 typedef int DataType; //栈元素类型定义 typedef struct{ DataType stack[StackSize]; int top; }SeqStack; //将栈初始化为空栈只需要把栈...
一篇文章带你解析完整数据结构-----满满干活值得收藏
最新发布
yuanbenshidiaos的博客
08-10 1022
定义：抽象数据类型是一组数据和施加于其上的一组操作的总称，它定义了数据的逻辑特性及其操作接口，而不涉及具体的实现细节。例子：栈、队列、列表等都是抽象数据类型的例子。特性数据抽象：只关注数据的逻辑特性，而不关心数据在计算机中的具体表示。封装性：数据和操作被封装在一起，对外提供统一的接口。理解这些概念是深入学习和应用数据结构的基础。在实际编程中，选择合适的数据结构对于编写高效、可维护的代码至关重要。定义：一个数学模型以及定义在此模型上的一组操作。举例：栈、队列、线性表、树等。
练习数据结构上机题1
NI3E
03-13 2630
数据结构上机练习题几道，线性表部分
数据结构与算法上机题目及答案
10-20
数据结构上机的参考题目以及优质代码，有兴趣的同学可下载作为参考
数据结构各个上机实验题及答案范例
10-20
数据结构各个上机实验题及答案范例，全部原创，上机运行正确，可以参考哟
数据结构(c语言)上机实践考试历年试题汇总doc
06-22
"数据结构(c语言)上机实践考试历年试题汇总doc" 本资源是一份数据结构（C语言）上机实践考试的历年试题汇总文档，该文档包含了多道编程题目，涵盖了数据结构的多个方面，包括图、矩阵、树、排序算法等。这些题目都...
计算机专业硕士211 985高校历年上机真题汇总.zip
03-31
2. 计算机专业基础：考研上机考试通常涵盖计算机科学与技术的基础知识，如数据结构、算法分析、操作系统、计算机网络、数据库原理等。考生需要熟练掌握这些领域的基本概念、原理和方法，并具备一定的编程能力。 3. ...
南京理工大学 计算机科学学院 研究生复试 上机考试 历年试题真题汇总整理.zip
03-31
1. 数据结构与算法：这部分内容是计算机科学的基础，包括数组、链表、树、图等基本数据结构，以及排序、搜索等算法。考生需要熟练掌握这些基础知识，并能灵活运用解决实际问题。 2. 编程语言：常见的编程语言如C、...
java 上机练习题
Liu_wen_wen的博客
06-26 2386
1.求圆柱体的面积和体积 2.交换盒子中的数字 3.求其各各位上的数字之和 4.判断奇偶 5.求三个数中的最大值6.抽奖活动 7.简单的计算器 8.判断星期几 9.工资奖金组成 10.计算几何图形的面积 11.根据输入的年利润计算企业提取的储备金 12.升级第7题的计算器 13.斐波那契数列 14.平均值 16.实现整数反转输出 17.根据每年增长25%计算人数 18.水仙花数 19.输出摄氏温度与华氏温度的对照表 20.整数相加 ...
数据结构上机考试试题（C++语言版）
12-30
顺序方式存储的线性表， 动态链接方式存储的线性表， 动态链接结构存储的二叉树， 选择排序的算法，
数据结构模拟上机试题
10-25
数据结构模拟上机试题，适合学习完整本书，综合练习。
数据结构上机题目（C语言）
12-30
按行优先排列 进行直接插入排序 二叉树前序和中序序列来构造该二叉树 与输入次序相反的次序输出这串整数 构造该完全二叉树 造带权无向图G
数据结构上机实验经典题目
11-17
数据结构上级经典题目，练手用最好，有点难度，希望好好利用
线性表的顺序表示和实现
weixin_45774615的博客
01-13 1120
含注释，用c++实现类和基本语法（但动态内存分配是用的c语言的malloc）
数据结构上机测试
qq_45144861的博客
07-21 332
（1）编写算法，将二个升序链表在原表空间上合并成一个升序链表，须自行写出测试样例进行测试，截图为证。 解答： （1）源代码 #include<stdio.h> #include<stdlib.h> //定义结构体 typedef struct node{ int data;//数据域 struct node* next;//指针域 }ElemSN; //头插法创建单向链表 ElemSN *PreCreatLink(int a[],int n) { ElemSN *hea
数据结构上机题——二叉树
小新
12-11 706
1.判断一个二叉树是否为完全二叉树 思路：设置一个标志位，当遇到一个空节点时，将标志位为修改；当后面在遇到有效节点并且标志位被修改时，则该二叉树不是完全二叉树。 template bool BinaryTree::JudgeTree1() { BinaryTreeNode* pointer = root; ArrayQueue&amp;lt;BinaryTreeNode* &amp;gt; queue(100);...
数据结构上机题目--MST
crazy_石头的专栏
10-28 805
prim算法 /************************************************************************* * author:crazy_石头 * algorithm:prim * date:2013/09/29 * 程序功能:MST * 算法流程:1.先选取一个点作起始点，然后选择它邻近的权值最小的点 （如果有多个与其相连的相同最小权值的
C语言实现数据结构上机题：统计重复元素
"这是一份关于数据结构的北京大学上机实践考试试题，具体是题号3.2，包含一道编程题目，要求处理一个整数数组，找出数组中出现次数最多且等于n-1的元素。提供的代码是用C语言实现的解决方案。" 在数据结构的学习中...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值