精华内容
下载资源
问答
  • 大学上数据结构课程自己写的数据结构实验,供参考 其中包括:学生管理系统(链表),算术表达式求值(栈和队列),KMPandBF算法,Huffman树和Huffman编码,完全二叉树的操作,学生管理系统plus(排序和查找)
  • 哈工大数据结构与算法全部实验汇总,包括代码和实验报告,供给广大学弟学妹。学艺不精,有不足的地方希望大家多多包涵,进行改进。
  • 据 结 构 课 程 设 计 设计题目:两个链表的交叉合并 专业班级08软件工程3班 姓名xxxxxx 学号080107031123 设计时间2010/9/25 指导教帅杨薇薇 一 设计题目 实现两个链表的合并 设计目的 .掌握线性链表的建立 ....
  • 报告规范详尽 好像先前一份传错了啊~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  • 数据结构实验报告(一)学生信息管理系统

    千次阅读 多人点赞 2020-01-12 10:58:03
    大二计算机学生报告的汇总 进入计算机专业以来每天的必要工作就是写报告,...报告汇总之c语言数据结构报告篇(一) 学生信息管理系统 代码区 代码说明:此代码所运用的软件是ios系统的x-code #include <stdio.h...

    大二计算机学生报告的汇总

    进入计算机专业以来每天的必要工作就是写报告,按照老师的话来说,我们计算机专业的学生经过长时间的训练,以后出去写代码就跟喝水一样简单.在这里我将发表部分我写的报告,仅以此怀念我的大二时光.(报告写的不好.仅供欣赏)

    报告汇总之c语言数据结构报告篇(一)

    学生信息管理系统

    代码区

    代码说明:此代码所运用的软件是ios系统的x-code

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    int sum;
    //创建一个学生的信息结构体
    typedef struct student{
        long id;
        char name[64];
        float grade;
    }s;
    //定义顺序表
    typedef struct {
        s* student;
        int length;
    }SqList;
    //构造空顺序表
    int CreatStudent(SqList*L){
        L->student=(s*)malloc(sizeof(s));
        if (L->student==NULL)
            return 0;
        else
        {
            L->length=0;
            return 1;
        }
    }
    //录入基础学生信息和需要插入的学生信息
    void GetStudent(SqList*L,int i){
        printf("请输入学生的学号:");
        scanf("%ld",&L->student[i].id);
        printf("请输入学生的姓名:");
        scanf("%s",L->student[i].name);
        printf("请输入学生的成绩:");
        scanf("%f",&L->student[i].grade);
        L->length++;
    }
    void jiaohuan(SqList*L,int i);
    //打印学生信息
    void PrintStudent(SqList*L,int i)
    {
        printf("%ld\n%s\n%.3f\n\n",L->student[i].id,L->student[i].name,L->student[i].grade);
    }
    //查找指定的学生信息
    void FindStudent (SqList*L)
    {
        int n;
        printf("请输入查找方式:\n0=学号查找\n1=存储位置查找");//查找方式的选择
        scanf("%d",&n);
        printf("请输入需要查找学生的信息:");
        switch (n) {
            case 0:
            {
                long number;//输入需要查找的学生学号
                scanf("%ld",&number);
                for (int i=0;i<=L->length;i++)
                {
                    if (number==L->student[i].id)
                        PrintStudent(L,i);//打印出查找到的学神信息
                }
                break;
            }
            case 1:
            {
                int number;
                scanf("%d",&number);//输入需要查找的学生位置
                PrintStudent(L,number-1);
                break;
            }
            default:
                printf("您输入的查找方式有误请确认后再操作");
                break;
        }
        
    }
    //删除指定的学生信息
    void DeletStudent (SqList*L,int i)
    {
        if(i<0||i>sum)
            printf("输入信息有误");
        else
        {
            for (int m=i-1;m<sum;m++)
            {
                L->student[m]=L->student[m+1];
            }
            //删除
            sum--;
            L->length--;
        }
    }
    //更新表中的学生信息
    void ReGetStudent (SqList*L)
    {
        int p;
        printf("请输入需要更新的位置:");
        scanf("%d",&p);
        GetStudent(L, p-1);
    }
    void charu(SqList* L)
    {
        printf("请输入需要插入的位置:");
        int p;
        scanf("%d",&p);
        GetStudent(L, sum);
        sum++;
        for (int i=sum-1;i>p-1;i--)
            jiaohuan(L,i);
        
        
    }
    void jiaohuan(SqList*L,int i)
    {
        long a;
        a=L->student[i-1].id;
        L->student[i-1].id=L->student[i].id;
        L->student[i].id=a;
        char b[64];
        strcpy(b, L->student[i-1].name);
        strcpy(L->student[i-1].name,L->student[i].name);
        strcpy(L->student[i].name, b);
        float c;
        c=L->student[i-1].grade;
        L->student[i-1].grade=L->student[i].grade;
        L->student[i].grade=c;
        
    }
    void paixu (SqList*L)
    {
        printf("请输入排序的要求:0代表学号;1代表成绩");
        int m;
        scanf("%d",&m);
        switch (m) {
            case 0:
                while (1)
                {
                    int f=0,q=0;
                    f=q;
                    for (int i=0;i<sum-1;i++)
                        if (L->student[i].id>L->student[i+1].id)
                        {
                            jiaohuan(L, i+1);
                            f=1;
                        }
                        else f=0;
                    if (f==0)
                        break;
                    
                }
                break;
                
            case 1:
                while (1)
                {
                    int f=0,q=0;
                    f=q;
                    for (int i=0;i<sum-1;i++)
                        if (L->student[i].grade>L->student[i+1].grade)
                        {
                            jiaohuan(L, i+1);
                            f++;
                        }
                    if (f==q)
                        break;
                }
                break;
        }
    }
    
    void qingkong (SqList*L)
    {
        L->length=0;sum=0;
    
        printf("所有数据已经清空");
    }
    
    int main()
    {
        SqList *text=(SqList*)malloc(sizeof(SqList)*10000);
        //为text划分存储空间
        CreatStudent(text);
        printf("共有多少名学生:");
        //录入基础有多少学生
        scanf("%d",&sum);
        text->length=0;
        for (int i=0;i<sum;i++)
            GetStudent(text,i);
        //获得基础学生信息
        int c;
        printf("(1)显示:显示当前所有学生信息记录;\n");
        printf("(2)录入:从键盘输入一条学生信息记录,插入到表中指定的位置;\n");
        printf(" (3)查找:根据学号或者记录的位置查找学生的各项信息;\n");
        printf("(4)删除:删除指定位置的学生信息记录;\n");
        printf("(5)更新:更新指定位置的学生信息记录;\n");
        printf("(6)统计:统计表中学生人数。\n");
        printf(" (7) 排序:按照学号或者绩点进行排序\n");
        printf("(8)清空:清空表中所有记录\n");
        int p=1;
        while (p==1)
        {
            printf("请输入你的操作指令:\n");
            scanf("%d",&c);
            switch (c) {
                case 1:
                    for (int i=0;i<sum;i++)
                        PrintStudent(text,i);
                    break;
                case 2:
                    charu(text);
                    break;
                case 3:
                    FindStudent(text);
                    break;
                case 4:
                {
                    int m;
                    printf("请输入需要删除学生的位置:");
                    scanf("%d",&m);
                    DeletStudent(text, m);
                }
                    break;
                case 5:
                    ReGetStudent(text);
                    break;
                case 6:
                    printf("学生的总数是:%d",sum);
                    break;
                case 7:
                    paixu(text);
                    break;
                case 8:
                    qingkong(text);
                    break;
                case 0:
                    p=0;
                    break;
                default:
                    printf("输入指令不对,请重新输入如果退出请输入0;");
                    break;
            }
        }
    }
    
    

    报告区

    第一部分:实验分析与设计(可加页)
    一、 实验内容描述(问题域描述)
    设计一个学生信息管理系统,实现对学生基本信息的添加、删除、修改和查询等操作,其中每个学生信息包含学号,姓名和绩点。要求系统完成以下主要功能:
    (1)显示:显示当前所有学生信息记录;
    (2)录入:从键盘输入一条学生信息记录,插入到表中指定的位置;
    (3)查找:根据学号或者记录的位置查找学生的各项信息;
    (4)删除:删除指定位置的学生信息记录;
    (5)更新:更新指定位置的学生信息记录;
    (6)统计:统计表中学生人数。
    (7) 排序:按照学号或者绩点进行排序
    (8)清空:清空表中所有记录

    二、 实验基本原理与设计(数据结构设计与算法设计)

    (1) 显示利用栈的顺序遍历输出每一个学生的信息;
    (2) 录入需要先通过遍历找到需要插入的位置,然后获取需要录入的学生的信息,利用尾插法插入该学生信息。
    (3) 查找通过遍历每一个学生的信息和所拥有的数据进行对比最终得出结果
    (4) 删除直接从该位置开始后面的学生信息向前进一
    (5) 先通过查找找到指定位置然后对其中的元素信息进行替换
    (6) 遍历过程中设置一个变量让其每次加一
    (7) 对所需要排序的内容进行比较如果不一致则进行交换并将变量j++;重复循环直到变量j为0;
    (8) 清空令length为0;
    三、主要仪器设备及耗材
    1.PC机
    2.开发环境(比如:VC,Eclipse)
    X-code
    第二部分:实验调试与结果分析(可加页)
    一、 调试过程(包括调试方法描述、实验数据记录,实验现象记录,实验过程发现的问题等)
    1.调试方法描述
    ① 输入c程序,并保存;
    ② 编译c程序,找出程序的语法错误并改正;
    ③ 输入测试数据,运行c程序;
    ④ 若有错利用断点一步步运行查错
    ⑤ 重复②-④步,直到得到正确的运行结果。

    2.实验输入/输出数据记录
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    4.实验过程发现的问题

    在设计除排序算法外的算法的时候没有什么太大问题;在设计排序算法时,我发现总会出现未完全排序的情况,因为顺序表与链表不同不能排序过程中直接插入,直到我引入了一个新的变量,让他来检验排序是否完全完成;虽然时间复杂度有所上升,但是能较好的完成功能的需要。

    二、 实验结果及分析(包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等)
    1.结果描述
    功能1-8全部都能正常实现;没有意外。
    2.实验现象分析
    所有程序经调试均符合题目要求。
    3.影响因素讨论
    ① 程序的输入提示不够,不知道何时需要输入数据,所以要增加输入提示,提示用户改做什么;
    ② 输出提示不够,输出结果不太清晰;
    4.算法分析(包括时间和空间)
    T(n)=o(n3);
    5.结论
    顺序表便于查找指定位置的内容,也便于顺序查找,但是在插入的时候不是很方便;总体来说这个实验我做的时间不算长但是其中的思路还是花了点时间。顺序表还是很实用的。
    三、 实验小结、建议及体会
    通过这次上机实验,使我对顺序表有了更加深刻的理解,结构体的用法也更加熟练,虽然在编程中出现了很多错误,但是最终错误都得以解决,让我下一次遇到这些问题更加的得心应手。锻炼了我的逻辑能力。
    运用顺序表来写一个学生管理系统,有其优势就是统计显示比较方便快捷,但是也有其劣势那就是录入和删除的繁琐,每一次录入删除需要移动所有数据。但好在在排序上,顺序表的便捷和可读比链表好。
    下一次遇到顺序表和链表的问题时可以多比较一下其各自的时间和空间复杂度,选择更加便捷不容易出错的作为一开始的思路。
    算法在节省空间存储的基础上却又加大了程序运行时间的开销,空间与时间是难以兼得的熊和鱼掌,程序员编写的时候需要考虑侧重点

    展开全文
  • 金陵科技学院实验报告 学 生 实 验 报 告 册 理工类 课程名称算法与数据结构 专业班级 _ 学生学号_ 所属院部 ------------ 学生姓名 _ 指导教师 20 13 20 14 学年 第 2 学期 金陵科技学院教务处制 金陵科技学院实验...
  • 报告汇总之c语言数据结构报告篇(二) 简单计算器 代码区 #include <stdio.h> #include <stdlib.h> char S[100]; char S2[100]; int i=0; //用来存储计算对数据 typedef struct sqlist { ...

    报告汇总之c语言数据结构报告篇(二)

    简单计算器

    代码区

    #include <stdio.h>
    #include <stdlib.h>
    
    char S[100];
    char S2[100];
    int i=0;
    
    //用来存储计算对数据
    typedef struct sqlist
    {
        char data[100];
        int top;
    }s1;
    //初始化数据栈
    void initSqlist (s1*L)
    {
        L=(s1*)malloc(sizeof(s1));
        L->top=-1;
    }
    //数据栈进栈
    void pushs1 (s1*L,char c)
    {
        L->top++;
        L->data[L->top]=c;
    }
    //数据栈进栈
    int  pop (s1*L)
    {
        int i;
        i=L->top;
        L->top--;
        return L->data[i];
    }
    //创建运算符栈
    typedef struct
    {
        char op[100];
        int top;
    } c1;
    //初始化运算符栈
    void initc1 (c1*P)
    {
        P=(c1*)malloc(sizeof(c1));
        P->top=-1;
    }
    //运算符压栈
     void pushc1 (c1*P,char c)
    {
        P->top++;
        P->op[P->top]=c;
    }
    //运算符出栈
    char popc1 (c1*P)
    {
        int i=P->top;
        P->top--;
        return P->op[i];
    }
    //获得需要处理的式子
    void get (char s1[100])
    {
        int i=0;
        scanf("%s",s1);
        while (s1[i]!=';')
        {
            printf("%c",s1[i]);
            i++;
        }
        printf("\n");
    }
    void changeguohao (char S[100],s1*L,c1*P,int i);
    //变换中缀为后缀
    void change (char S[100],s1*L,c1*P,int i)
    {
        get(S);
        printf("后缀表达式为:");
        char a;
        while (S[i-1]!=';')
        {
            int s=-1;
            if (S[i]=='(')
            {
                    s=P->top;
            }
            if (S[i]=='('||S[i]==')')
            {
                if (S[i]==')')
                {
                    
                    while (P->top!=s)
                    {
                        a=popc1(P);
                        printf("%c",a);
                    }
                }
                i++;
            }
            if (S[i]>=49&&S[i]<=57)
            {
                pushs1(L,S[i]);
                a=pop(L);
                printf("%c",a);
            }
            if (S[i]==';')
                while (P->top!=-1) {
                    a=popc1(P);
                    printf("%c",a);
                }
            if (S[i]=='+'||S[i]=='-')
            {
                if (S[i-2]=='+'||S[i-2]=='-')
                {
                    a=popc1(P);
                    printf("%c",a);
                }
                pushc1(P,S[i]);
            }
            if (S[i]=='*'||S[i]=='/')
            {
                pushc1(P, S[i]);
                if(S[i+1]!='(')
                {
                    i++;
                    pushs1(L,S[i]);
                    a=pop(L);
                    printf("%c",a);
                }
                while (P->top!=-1&&S[i+1]!='(')
                {
                    a=popc1(P);
                    printf("%c",a);
                }
                //i++;
                //pushc1(P,S[i]);
            }
            i++;
        }
    
    }
    //变换有括号时的中缀表达式
    void changeguohao (char S[100],s1*L,c1*P,int i)
    {
        char a;
        if (S[i]==')')
        {
            while (P->top!=-1)
            {
                a=popc1(P);
                printf("%c",a);
            }
            i++;
        }
        change(S, L, P, i);
    }
    //计算后缀表达式
    int clculate (char S[100],s1*L,c1*P,int i)
    {
        printf("请输入您需要处理的后缀表达式:");
        get(S);
        i=0;
        char a;
        char b;
        int c=0;
        char d = '0';
        L->top=-1;
        while (S[i]!=';')
        {
            if (S[i]>=49&&S[i]<=57)
                pushs1(L, S[i]);
            //数据压栈
            else
            {
                //对运算符进行判断,进行计算
                if (S[i]=='+')
                {
                    a=pop(L);
                    b=pop(L);
                    c=(a-'0')+(b-'0');
                    d=c+'0';
                    pushs1(L, d);
                }
                if (S[i]=='-')
                {
                    a=pop(L);
                    b=pop(L);
                    c=(b-'0')-(a-'0');
                    d=c+'0';
                    pushs1(L, d);
                }
                if (S[i]=='*')
                {
                    a=pop(L);
                    b=pop(L);
                    c=(a-'0')*(b-'0');
                    d=c+'0';
                    pushs1(L, d);
                }
                if (S[i]=='/')
                {
                    a=pop(L);
                    b=pop(L);
                    c=(b-'0')/(a-'0');
                    d=c+'0';
                    pushs1(L, d);
                }
            }
            i++;
        }
        return c;
    }
    int main ()
    {
        s1 *L;
        L=(s1*)malloc(sizeof(s1));
        //initSqlist(L);
        L->top=-1;
        c1 *P;
        P=(c1*)malloc(sizeof(c1));
        //initc1(* &P);
        P->top=-1;
        while (1)
        {
            printf("请输入您需要进行的操作:");
            printf("0代表转换为后缀表达式;1代表计算后缀表达式结果\n");
            int n;
            scanf("%d",&n);
            getchar();
            switch (n)
            {
                case 0:
                {
                    printf("中缀表达式为:");
                    change(S, L, P,i);
                    printf("\n");
                    break;
                }
                case 1:
                {
                    
                    printf ("计算的结果为:%d",clculate(S, L, P, i));
                    printf("\n");
                    break;
                }
                default:
                    break;
            }
        }
        return 0;
    }
    
    

    报告区

    一、 实验内容描述(问题域描述)
    编写程序,模拟简单运算器的工作:输入一个算式(没有空格),遇等号“=”说明输入结束,输出结果。假设计算器只能计算加减乘除运算,运算数和结果都是整数。要求完成以下功能:
    (1) 从键盘录入中缀表达式,将中缀表达式转换为后缀表达式输出;
    (2) 输入后缀表达式,计算后缀表达式的值。
    二、实验基本原理与设计(数据结构设计与算法设计)
    (1)利用顺序栈进行存储和运算运算符和数字
    (2)在读入信息时碰到数字就输出,碰到字符先入栈比较后输出
    (3)在进行计算时直接运算,把运算后的结果入栈;直至把最终结果出栈
    第二部分:实验调试与结果分析(可加页)
    一、 调试过程(包括调试方法描述、实验数据记录,实验现象记录,实验过程发现的问题等)
    1.调试方法描述
    ① 输入c程序,并保存;
    ② 编译c程序,找出程序的语法错误并改正;
    ③ 输入测试数据,运行c程序;
    ④ 若有错利用断点一步步运行查错
    ⑤ 重复②-④步,直到得到正确的运行结果。

    2.实验输入/输出数据记录
    在这里插入图片描述
    3.实验过程发现的问题
    在进行减法运算的时候我们需要注意是谁减谁,除法运算也一样。开始我并没有注意到这一点,导致后面的结果错误很多。
    在把中缀转后缀的过程中我忘记将括号删去导致一开始输出时括号一起输出;带括号的转换
    的复杂程度明显高于不带括号所以我将其单独列出便于查看。
    二、 实验结果及分析(包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等)
    1. 结果描述
    转换过程和计算过程全部正确;结果输出无误。
    2. 实验现象分析
    所有程序经调试均符合题目要求。
    3.影响因素讨论

    4.算法分析(包括时间和空间)
    空间复杂度为 Sn=O(100)
    时间复杂度为Tn=O(n)
    5.结论
    经过多次调试,所有程序最终运行都成功了。

    三、 实验小结、建议及体会
    学习C语音需要有很大的耐心与毅力,对我们的身体的脑力都是一项很大的挑战。敲了快整整一 周的代码,虽然很累,很烦琐,偶尔还会 被题目难倒,压力山大。可当自己将题目一
    题一题的解决时,心中更多的是成就感,多了一分慰藉。在接下来的日子里,要更加努力好好学专业基础,稳固提升。在课余时间更加注重劳逸结合,多运动,多锻炼,这样学习更有效率。

    展开全文
  • 一、实验目的 1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。 2、学会比较各种排序与查找算法的优劣。 3、学会针对所给问题选用最适合的算法。 4、掌握利用常用的排序与选择算法的思想来解决一般...

                                       学生信息管理系统

    一、实验目的

    1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。

    2、学会比较各种排序与查找算法的优劣。

    3、学会针对所给问题选用最适合的算法。

    4、掌握利用常用的排序与选择算法的思想来解决一般问题的方法和技巧。

    二、实验内容

    [问题描述]

     学生信息管理系统

    [基本要求]

    设计一个学生信息管理系统,学生对象至少要包含:学号、姓名、性别、成绩1、成绩2、总成绩等信息。要求实现以下功能:

    1.试选择一种方式存储:基于数组、链表或文件方式

    2.总成绩要求自动计算;

    3.查询:分别给定学生学号、姓名,能够查找到学生的基本信息(要求至少用两种查找算法实现);

    排序:分别按学生的学号、总成绩进行排序(要求至少用两种排序算法实现)。

    [测试数据]

    由学生依据软件工程的测试技术自己确定。

    [源代码及注释]

    #include<stdio.h>
    #include<string.h>
    #define MAXSIZE 111
    typedef struct{
    long long ID;                               //学号
    char Name[20];                              //性别
    char Sex[5];                                //性别
    int Chinese;                                //语文成绩
    int English;                                //英语成绩
    int Math;                                   //数学成绩
    int SumScore;                               //总分
    }student;
    typedef struct{
    student *stu;
    int length;
    }List;
    void InitList(List &L);                         //初始化学籍系统
    void Creat(List &L);                            //创建学籍系统
    void Print(List &L);                            //打印所有学生信息
    void SinglePrint(List &L,int i);                //打印单一学生信息
    void InsertSort(List &L);                       //按照学号进行插入排序
    
    int Partition(List &L,int low,int high);        //按照总分
    void QSort(List &L,int low,int high);           //进行
    void QuickSort(List &L);                        //快速排序
    
    void Sort(List &L);                             //排序汇总
    void Search_Seq(List &L,char key[]);            //按照姓名进行顺序查找
    void Search_Bin(List &L,long long key);         //按照学号进行二分查找
    void Search(List &L);                           //查找汇总
    
    void InitList(List &L)
    {
        L.stu=new student[MAXSIZE];
        L.length=0;
    }
    void Creat(List &L)
    {
        printf("请输入学生总数:");
        int n;
        scanf("%d",&n);
        printf("请依次输入%d个学生的学号、姓名、性别、语文、英语、数学,用空格隔开\n",n);
        for(int i=1;i<=n;++i)
        {
            scanf("%lld%s%s%d%d%d",&L.stu[i].ID,L.stu[i].Name,L.stu[i].Sex,&L.stu[i].Chinese,&L.stu[i].English,&L.stu[i].Math);
            L.stu[i].SumScore=L.stu[i].Chinese+L.stu[i].English+L.stu[i].Math;
            ++L.length;
        }
    }
    void Print(List &L)
    {
        printf("    学号       姓名    性别   语文   英语   数学    总分\n");
        printf("--------------------------------------------------------\n");
            for(int i=1;i<=L.length;++i)
        printf("%12lld   %-6s   %s     %-2d     %-2d     %-2d     %-3d\n",L.stu[i].ID,L.stu[i].Name,L.stu[i].Sex,L.stu[i].Chinese,L.stu[i].English,L.stu[i].Math,L.stu[i].SumScore);
    }
    void SinglePrint(List &L,int i)
    {
        printf("    学号       姓名    性别   语文   英语   数学    总分\n");
        printf("--------------------------------------------------------\n");
        printf("%12lld   %-6s   %s     %-2d     %-2d     %-2d     %-3d\n",L.stu[i].ID,L.stu[i].Name,L.stu[i].Sex,L.stu[i].Chinese,L.stu[i].English,L.stu[i].Math,L.stu[i].SumScore);
    }
    void InsertSort(List &L)
    {
        int i,j;
        for(i=2;i<=L.length;++i)
        if(L.stu[i].ID<L.stu[i-1].ID)
        {
            L.stu[0]=L.stu[i];
            L.stu[i]=L.stu[i-1];
            for(j=i-2;L.stu[0].ID<L.stu[j].ID;--j)
                L.stu[j+1]=L.stu[j];
                L.stu[j+1]=L.stu[0];
        }
    }
    int Partition(List &L,int low,int high)
    {
        L.stu[0]=L.stu[low];
        int temp=L.stu[low].SumScore;
        while(low<high)
        {
            while(low<high&&L.stu[high].SumScore>=temp)
                --high;
            L.stu[low]=L.stu[high];
            while(low<high&&L.stu[low].SumScore<=temp)
                ++low;
            L.stu[high]=L.stu[low];
        }
        L.stu[low]=L.stu[0];
        return low;
    }
    void QSort(List &L,int low,int high)
    {
        if(low<high)
        {
            int mid=Partition(L,low,high);
            QSort(L,low,mid-1);
            QSort(L,mid+1,high);
        }
    }
    void QuickSort(List &L)
    {
        QSort(L,1,L.length);
    }
    void Sort(List &L)
    {
        QuickSort(L);
        printf("按照总分进行快速排序后:\n");
        Print(L);
        InsertSort(L);
        printf("按照学号进行插入排序后:\n");
        Print(L);
    }
    void Search_Seq(List &L,char key[])
    {
        printf("顺序查找:\n");
        int flag=0;
        for(int i=1;i<=L.length;++i)
        if(strcmp(L.stu[i].Name,key)==0)
        {
            flag=1;
            printf("已经找到,该学生信息如下:\n");
            SinglePrint(L,i);
        }
        if(!flag)
            printf("没有找到!\n");
    }
    void Search_Bin(List &L,long long key)
    {
        printf("二分查找:\n");
        int low=1,high=L.length,mid;
        while(low<=high)
        {
            mid=(low+high)/2;
            if(key==L.stu[mid].ID)
            {
            printf("已经找到,该学生信息如下:\n");
            SinglePrint(L,mid);
            return;
            }
            else if(key<L.stu[mid].ID)
                high=mid-1;
            else
                low=mid+1;
        }
        printf("没有找到!\n");
        return;
    }
    void Search(List &L)
    {
        printf("请输入查找次数:");
        int times;
        scanf("%d",&times);
        while(times--)
        {
            int way;
            printf("请输入一个数字代表查询方式,1代表按照学号使用二分法查询,其他代表按照姓名使用顺序法查询:");
            scanf("%d",&way);
            if(way==1)
            {
                printf("请输入要查找的关键字:");
                long long key;
                scanf("%lld",&key);
                Search_Bin(L,key);
            }
            else
            {
                printf("请输入要查找的关键字:");
                char key[20];
                scanf("%s",key);
                Search_Seq(L,key);
            }
        }
    }
    int main()
    {
        List L;
        InitList(L);
        Creat(L);
        Sort(L);
        Search(L);
        return 0;
    }
    

    【运行结果】

                       

     

    展开全文
  • 学 生 实 验 报 告 册 理工类 课程名称算法与数据结构 专业班级 _ 学生学号_ 学生姓名 _ 所属院部 指导教师 20 13 20 14 学年 第 2 学期 金陵科技学院教务处制 实验报 书写要求 实验报告原则上要求学生手写要求书写...
  • 数据结构教程上机实验指导 李春葆,实验题和练习题答案汇总
  • //定义空字符串,储存从BUFf中读到的每一行数据 while((s=buff.readLine())!=null){ student.add(s); //将读到的字符串存放到ArrayList中 } buff.close(); //关闭连接 file.close(); } ...

     

    1:希腊字母打印

    
    public class GreekAlphabet {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    		char cStart='α',cEnd = 'ω';
    		while(cStart<=cEnd){
    			System.out.print(cStart+++",");
    			
    		}
    	}
    
    }
    
    α,β,γ,δ,ε,ζ,η,θ,ι,κ,λ,μ,ν,ξ,ο,π,ρ,?,σ,τ,υ,φ,χ,ψ,ω,

    2:猜数字游戏

    import java.util.Scanner;
    import java.util.Random;
    public class GuessNumber {
       public static void main (String args[]) {
          @SuppressWarnings("resource")
    	Scanner reader = new Scanner(System.in);
          Random random = new Random();
          System.out.println("给你一个1至100之间的整数,请猜测这个数");
          int realNumber = random.nextInt(100)+1; //random.nextInt(100)是[0,100)中的随机整数
          int yourGuess = 0;
          System.out.print("输入您的猜测:");  
          yourGuess = reader.nextInt();
          while(yourGuess!=realNumber) //循环条件
          {
             if(yourGuess>realNumber)   //猜大了的条件代码
             {
                 System.out.print("猜大了,再输入你的猜测:");
                 yourGuess = reader.nextInt();
             }
             else if(yourGuess<realNumber) //猜小了的条件代码
             {
                 System.out.print("猜小了,再输入你的猜测:");
                 yourGuess = reader.nextInt();
             }
          }
          System.out.println("猜对了!");
       }
    }
    

     

    3:回文数

    import java.util.Scanner;
    public class Number{
    public static void main(String[] args){
    
    
    	int number=0, number2=0;
    	Scanner read=new Scanner(System.in);
    	System.out.println("Input a number:");
    	number = read.nextInt();
    	int d5,d4,d3,d2,d1;//万千百十个位
    if(number>0&&number<100000){
    	d5=number/10000%10;//万位的数
    	d4=number/1000%10;//千位
    	d3=number/100%10;//百位
    	d2=number/10%10;//十位
    	d1=number%10;//个位
    	if(number<100000&&number>9999){
    		number2=d1*10000+d2*1000+d3*100+d4*10+d5;
    	}else if(number>999&&number<10000){
    		number2=d1*1000+d2*100+d3*10+d4;
    	}else if(number>99&&number>1000){
    		number2=d1*100+d2*10+d3;
    	}else if(number>9&&number<100){
    		number2=d1*10+d2;
    	}else 
    		if(number<10&&number>0)number2=number;
    	if(number==number2)
    	{System.out.println(number+"是回文数");}
    	else {System.out.println(number+"不是回文数");
    }	
    }else {System.out.println("输入错误");
    }}
    }
    

    4:IBM计算

    package Lab6_1;
    
    import java.awt.FlowLayout;
    import java.awt.event.*;
    import java.text.DecimalFormat;
    import javax.swing.*;
    public class BMIWindow extends JFrame implements ActionListener{
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    	JLabel weight,height,BMI;
    	JTextField wtext,htext,BMIt;
    	JButton comput;
    	public BMIWindow(){
    		setTitle("BMI计算器");
    		weight=new JLabel("体重(Kg)");
    		height=new JLabel("身高(m)");
    		BMI=new JLabel("身体质量指数(BMI)");
    		wtext=new JTextField(20);
    		htext=new JTextField(20);
    		BMIt=new JTextField(16);
    		BMIt.setEditable(false);
    		comput=new JButton("计算BMI");
    		setLayout(new FlowLayout());
    		add(weight);add(wtext);
    		add(height);add(htext);
    		add(BMI);add(BMIt);
    		add(comput);
    		//添加事件
    		comput.addActionListener(this);
    		setBounds(200, 200, 310, 200);
    		setVisible(true);
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	}
    	public void actionPerformed(ActionEvent e) {
    		double wd=Double.valueOf(wtext.getText());
    		double hd=Double.valueOf(htext.getText());
    		double BMI=wd/hd/hd;
    		//String result=String.valueOf(BMI);
    		BMIt.setText(fit(BMI));	
    	}
    	//判断是否身体指数
    	public String fit(double bmi){
    		String b="";
    		if(bmi>35)b="非常严重超重";
    		else if(bmi>29)b="严重超重";
    		else if(bmi>24)b="超重";
    		else if(bmi>18)b="正常";
    		else if(bmi>16)b="偏轻";
    		else b="严重偏轻";
    		//保留两位小数
    		String a=new DecimalFormat("#.00").format(bmi);
    		return a+" "+b;	
    	}
    	public  static void main(String[] args ){
    		BMIWindow bw=new BMIWindow();
    	}
    }
    

     

    5:打字母游戏

    import java.awt.*;
    import java.awt.event.KeyEvent;
    import java.awt.event.KeyListener;
    
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    
    public class TypeGame {
    
    	public static void main(String[] args) {
    
    		JFrame window = new JFrame();
    		window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		window.setSize(300, 400);
    
    		PaintPanel panel = new PaintPanel();
    		window.add(panel);
    
    		Thread t = new Thread(panel);
    		t.start();
    		
    		window.setVisible(true);
    		panel.requestFocus();
    	}
    
    }
    
    class PaintPanel extends JPanel implements Runnable, KeyListener {
    	int x[] = new int[10];
    	int y[] = new int[10];
    	char c[] = new char[10];
    	int score = 1000;
    	int speed = 80;
    
    	PaintPanel() {
    		setBackground(Color.darkGray);
    		addKeyListener(this);
    		for (int i = 0; i < 10; i++) {
    			x[i] = (int) (Math.random() * 280)+10;
    			y[i] = (int) (Math.random() * 300);
    			c[i] = (char) (Math.random() * 26 + 97);
    		}
    	}
    
    	public void paintComponent(Graphics g) {
    		super.paintComponent(g);
    		g.setColor(Color.orange);
    		for (int i = 0; i < 10; i++) {
    			g.drawString(new Character(c[i]).toString(), x[i], y[i]);
    		}
    		
    		g.setColor(Color.red);
    		g.drawString("你的成绩是:" + score, 5, 10);
    	}
    
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		while (true) {
    			for (int i = 0; i < 10; i++) {
    				y[i]++;
    				if (y[i] > 400) {
    					y[i] = 0;
    					x[i] = (int) (Math.random() * 280)+10;
    					score -= 100;
    				}
    			}
    			try {
    				Thread.sleep(speed);
    			} catch (Exception e) {
    			}
    			repaint();
    			
    		}
    	}
    
    	@Override
    	public void keyPressed(KeyEvent e) {
    		char keyC = e.getKeyChar();
    		boolean flag = false;
    		for (int i = 0; i < 10; i++) {
    			if (keyC == c[i]) {
    				y[i] = 0;
    				x[i] = (int) (Math.random() * 280)+10;
    				c[i] = (char) (Math.random() * 26 + 97);
    				flag = true;
    				break;
    			}
    		}
    		if(flag){
    			score+=10;
    		}else{
    			score-=10;
    		}
    		
    	}
    
    	@Override
    	public void keyReleased(KeyEvent e) {
    	}
    	@Override
    	public void keyTyped(KeyEvent e) {
    	}
    }
    

     

     

    6:班级随机点名

    package views;
    
    import java.awt.*;
    import java.awt.event.*;
    import java.io.*;
    import java.util.*;
    import javax.swing.*;
    
    public class MainWindow extends JFrame implements ActionListener{
    	JButton jbutton=new JButton("开始点名");		//点名按键
    	Random r=new Random(); 						//随机数对象
    	ArrayList<String> student=new ArrayList<>();//数据存放数组	
    	String filepath="src/student.txt";			//文件路径
    	//构造函数
    	MainWindow(){
    		super("随机点名1.0");
    		init();									//窗口初始化
    		readfile();								//读取文件
    	}
    	public void init(){
    		jbutton.setBorderPainted(false);	//按钮无边框
    		jbutton.setFocusPainted(false);		//text无边框
    		jbutton.setBackground(Color.orange);//设置背景颜色
    		jbutton.setFont(new Font("宋体",Font.BOLD,40));	//设置字体大小
    		jbutton.setForeground(Color.white);
    		jbutton.addActionListener(this);
    		add(jbutton);	//添加到FRAME
    		this.setSize(500, 500);
    		this.setVisible(true);
    		this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    		}
    	
    	public void actionPerformed(ActionEvent e) {
    		int index=r.nextInt(student.size());
    		jbutton.setText(student.get(index));
    		
    	}
    	public void readfile(){
    		try {
    			FileReader file=new FileReader(filepath); //建立文件对象
    			BufferedReader buff=new BufferedReader(file);//读取文件到Buffer
    			String s;			//定义空字符串,储存从BUFf中读到的每一行数据
    			while((s=buff.readLine())!=null){
    				student.add(s);			//将读到的字符串存放到ArrayList中
    			}
    			buff.close();		//关闭连接
    			file.close();
    		} catch (Exception e) {
    			e.printStackTrace();
    		} 
    	}
    	
    	public static void main(String[] args){
    		MainWindow m=new MainWindow();
    		
    	}	
    }
    

     

     

    7:复制文件

    package copyFile;
    
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    
    import javax.swing.JButton;
    import javax.swing.JFileChooser;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    import javax.swing.JTextField;
    
    public class Copy extends JFrame implements ActionListener{
    	public static void main(String []args){
    	new Copy();	
    	}
    	
    	
    	JLabel readLabel;
    	JLabel writeLabel;
    	JTextField readFiled;
    	JTextField writeFiled;
    	JButton readBut;
    	JButton writeBut;
    	JButton yesBut;
    	JFileChooser filechooser;
    	String readPath;
    	String writePath;
    	
    	public Copy(){
    		readLabel=new JLabel("文件:");
    		writeLabel=new JLabel("保存到:");
    		readFiled=new JTextField(20);
    		writeFiled=new JTextField(20);
    		readBut=new JButton("选择");
    		writeBut=new JButton("选择");
    		yesBut=new JButton("确定");
    		
    		readBut.addActionListener(this);
    		writeBut.addActionListener(this);
    		yesBut.addActionListener(this);
    		
    		JPanel p=new JPanel();
    		p.add(readLabel);
    		p.add(readFiled);
    		p.add(readBut);
    		p.add(writeLabel);
    		p.add(writeFiled);
    		p.add(writeBut);
    		p.add(yesBut);
    		add(p);
    		this.setBounds(300, 300, 400, 400);
    		this.setVisible(true);
    		this.setTitle("复制文件");
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	}
    	public Boolean copyFile(String oldPath,String newPath){
    		if(oldPath==null||newPath==null)
    			return false;
    			System.out.println(oldPath+newPath);
    		try {
                int bytesum = 0;
                int byteread = 0;
                File oldfile = new File(oldPath);
                if (oldfile.exists()) { // 文件存在时
                    InputStream inStream = new FileInputStream(oldPath); // 读入原文件
                    System.out.println(newPath);
                   
                        FileOutputStream fs = new FileOutputStream(newPath);
                        byte[] buffer = new byte[1444];
                        while ((byteread = inStream.read(buffer)) != -1) {
                            bytesum += byteread; // 字节数 文件大小
                            System.out.println(bytesum);
                            fs.write(buffer, 0, byteread);
                        }
                        inStream.close();
                        fs.close();
                    }
            } catch (Exception e) {
                System.out.println("复制单个文件操作出错");
                e.printStackTrace();
                return false;
            }
    		return true;
    		
    	}
    	public void actionPerformed(ActionEvent e) {
    		JButton jbutton=(JButton)e.getSource();
    		if(jbutton==readBut){
    			System.out.println("readBut");
    			filechooser=new JFileChooser();
    			filechooser.setDialogTitle("选择要复制的文件");
    			if(filechooser.showOpenDialog(this)==JFileChooser.APPROVE_OPTION){
    				readPath=filechooser.getSelectedFile().getAbsolutePath();
    				readFiled.setText(readPath);
    			}
    		}
    		if(jbutton==writeBut){
    			System.out.println("writeBut");
    			filechooser=new JFileChooser();
    			filechooser.setDialogTitle("选择文件夹");
    			filechooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
    			if(filechooser.showSaveDialog(this)==JFileChooser.APPROVE_OPTION){
    				writePath=filechooser.getSelectedFile().getAbsolutePath()+"\\";
    				writeFiled.setText(writePath);
    			}
    			
    		}
    		if(jbutton==yesBut){
    			if(!copyFile(readPath,writePath)){
    				System.out.println("不能为空");
    			}
    		}
    		
    	}
    
    }
    

    二  java实验汇总 

     

    javaBase工程打包地址:https://www.lanzous.com/i71mm1i

    Java实验报告下载地址:https://www.lanzous.com/i71modc

    Java开发文档:https://www.lanzous.com/i71mqbc

    Java随机点名工程:下载:https://www.lanzous.com/i71mm2j 密码:8hb6

     

    数据结构实验地址

    数据库实验地址

     

     

     

    展开全文
  • 合集 | 南邮实验报告目录

    万次阅读 多人点赞 2020-02-10 15:02:20
    南邮各种学科编程类实验程序
  • 报告汇总之c语言数据结构报告篇(三) 家谱的查找 代码区 #include <stdio.h> #include <stdlib.h> //创建一个二叉链 typedef struct node { char data; struct node* lchild; struct node* rchild; }...
  • 数据结构 实验二 链表的基本操作

    千次阅读 2020-09-25 19:55:18
    从键盘输入数据,创建一个初始链表。通过调用定义的基本操作函数来实现单链表上的插入、删除元素等操作。调试程序并对相应的输出作出分析;修改输入数据,预期输出并验证输出的结果。加深对有关算法的理解。 相关...
  •   • 熟练掌握基本的数据预处理技术;   • 学会运用决策树、随机森林等方法解决分类任务。 1.2 实验任务   基于Molecular Biology DataSet完成分类任务,kNN、决策树、多层感知器、朴素贝叶斯、SVM、随机...
  • 报告规范详尽 好像先前一份传错了啊 我的实验报告 shujushiyan
  • 说明:这是武汉理工大学计算机学院数据结构与算法综合实验课程的第一次项目:二叉树与赫夫曼图片压缩实践代码。 源码下载地址:点击此处下载本次实验项目(运行环境:VS2017) 关注微信公众号【知行校园汇】可免费...
  • 设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。具体实现要求: 1. 从键盘输入10个整数,产生不带表头的单链表,并输入结点值。 2. 从键盘输入1个整数,在单链表中查找该结点的位置。若找到,...
  • 1、pandas的数据结构 - pandas是含有使数据清洗和分析工作变得更快更简单的数据结构和操作工具。pandas经常和其它工具一同使用,如数值计算工具NumPy和SciPy,分析库statsmodels和scikit-learn,和数据可视化库...
  • Sql Server 数据库实验报告

    万次阅读 多人点赞 2019-11-28 15:25:37
    数据库原理 实验报告 目录 实验一 SQL Server的安装和配置 4 一、实验目的 4 二、实验内容 4 三、实验步骤 4 四、实验代码和结果 4 五、实验总结与体会 4 实验二 创建数据库 5 一、实验目的 5 二、实验内容 5 三、...
  • 本次继续更新数据结构与算法这门课的上机实验,并且从本次开始将持续更新三篇关于排序和查找的内容——最根本的操作,主要涉及直接插入排序、快速排序(实验五)和 直接选择排序、两路并归排序(实验六)。
  • 实验名称 访问者模式的应用 日期 2018年 04 月2 日 ...某公司OA系统中包含一个员工信息管理子系统,该公司员工包括正式员工和临时工,每周人力资源部和财务部等部门需要对员工数据进行汇总汇总数据包括员工工...
  • 2、加深对图结构及算法的理解 3、培养解决实际问题的编程能力 实验内容: 国际象棋马的走法:先直走或横走一格,再沿离开原来格子的方向斜走二格,合起来为一步棋;国际象棋棋盘黑白交错,格数8×8。 基本要求: 给...
  • 报告汇总之c语言数据结构报告篇(四) 通信网的建立 代码区 // // main.c // 通信网构建 // // Created by tianyu on 2019/10/20. // Copyright © 2019 tianyu. All rights reserved. // #include <stdio.h> #...
  • 说明:这是武汉理工大学计算机学院【数据结构】课程的第二次实验:栈与队列的应用---表达式求值 >>点击查看WUTer计算机专业实验汇总 谨记:纸上得来终觉浅,绝知此事要躬行。 实验二:栈与队列的应用 ...
  • 数据库原理实验报告【全集】

    千次阅读 多人点赞 2020-02-13 20:34:46
    实验1~8:SQL Server 2008的安装及管理工具的...百度文库里都有这些实验报告,不过我还是想放一下我自己截的图,上传后就一律把实验报告们统统删除了。 学校电脑用SQL SERVER2008和快速截图可执行文件ScrToPic,...
  • 数据结构和算法

    2019-11-24 18:11:55
    https://time.geekbang.org/course/intro/130?utm_term=zeusOCS5C&utm_source=app&utm_medium=geektime&utm_campaign=130-end&utm_content=juhezhuanchang1124
  • 同一个问题可用不同的算法解决,而一个算法的质量优劣将影响到算法乃至程序的效率,算法的复杂度分为时间复杂度和空间复杂度。(算法的复杂性体现在运行该算法时的计算机所需资源的多少上,计算机资源最重要的是时间...
  • R系列实验汇总.zip

    2021-06-01 20:53:14
    内容:R基础实验【基本计算、回归、主成分分析、因子分析、程序流等】 注:均是我本人的实验报告,对应【R与统计】专栏的系列博客,代码仅供参考,欢迎斧正交流。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,460
精华内容 2,584
关键字:

数据结构实验报告汇总

数据结构 订阅