精华内容
下载资源
问答
  • 数据结构实训选题数数据结构实训选题据结构实训选题数据结构实训选题数据结构实训选题
  • 数据结构实训

    2008-07-03 20:27:41
    这是一个数据结构实训的例子(有代码哦!关于通讯录的,),有数据库设计的全过程,是同学实训时候作的,希望对大家有帮助...
  • 数据结构实训范文数据结构实习报告 数据结构实习报告规范 实习报告的开头应给出题目班级姓名学号和完成日期并包括以下七个内容 1需求分析 以无歧义的陈述说明程序设计的任务强调的是程序要做什么明确规定 1输入的...
  • 在网上看到许多数据结构实训的题目,内容及要求,和我这个差不多,可以提前看看,练习。
  • 数据结构实训 图书馆管理系统 包含增删查操作 运行无误
  • 数据结构实训》教学大纲 专业核心课程 数据结构(Data Structure)
  • 河南工程学院数据结构实训校园导航系统
  • 数据结构实训项目源代码
  • 纸牌游戏数据结构实训代码 实训要求 题目十三纸牌游戏 基本要求 一副没有花牌JQ K A大小王的扑克牌两个人进行纸牌游戏其中一 个人为用户另一个人为计算机 每轮每人各发 5 张牌各自以这 5张牌建立二叉排序树 由用户先...
  • 数据结构实训模板 教务管理系统
  • c++数据结构实训 病人就诊系统 本系统主要实现对病人就医进行管理。程序流程如下: 系统按照优先级和病历号进行排队,优先级高的排一个队,优先级低的排一个队,同等优先级则是先排队先就诊。只有优先级高的病人...
  • 数据结构实训总结PINGDINGSHAN UNIVERSITY数据结构实训院(系): 软件学院专业年级: 软件工程 2009级姓 名: 李乾坤学 号: 091530108指导教师: 刘高原 讲师2011年06月18日查找排序需求分析对一组无序数据进行排序,找出...

    数据结构实训总结

    PINGDINGSHAN UNIVERSITY

    数据结构实训

    院(系): 软件学院

    专业年级: 软件工程 2009级

    姓 名: 李乾坤

    学 号: 091530108

    指导教师: 刘高原 讲师

    2011年06月18日

    查找排序

    需求分析

    对一组无序数据进行排序,找出排序后某一数据所在的位置。

    概要设计 略

    详细设计 略

    算法分析

    简单地说,冒泡法就是先找最小值,再找次小值……,快排则是在一次循环中使它们局部有序,多次循环,直至全部有序为止。二分查找充分利用了有序序列的特性,从某种意义上讲,二分查找侧重的不是比较两个数是不是相等,而是确定要查找的数的范围。

    程序总结

    这个算法给我的最大启发就是我们要充分利用已有的信息。比如对已经排好序的数据进行查找,如果只是平淡的顺序查找,就比二分查找的效率低很多。为什么?因为二分查找考虑并利用了这些信息。同样的理论还可以用来解释为什么快排就比冒泡来得快,排序说白了就是为每一个数找到一个它应该呆的位置。假如为1~10排序,冒泡排序说白了就是一开始先找最大值移到最上边,这没错,关键是次小值又从底部开始找,使以前做的许多移动又有一部分重复了。快排则是,我不管以前怎么着,8碰到5就得放5的右边这总没错吧,以后碰到合适的再移动,但8和5的相对移动不会再重复了。由此观之,消除程序中的重复工作是提高效率的关键,不过高效率的算法可不是长在树上的(说有就有的),比如二分搜索排序,即使看起来很简单,能想起来这么做却是非常不简单的。

    0-1背包问题(Bag)

    需求分析

    从若干个具有一定价值和质量的物品挑出一些放入具有容量限制的背包,使背包的所容纳物品的价值最大。

    概要设计

    三个面板类,用card布局依次显示

    详细设计

    1)第一个card负责设置背包容量和最大物品个数

    2)第二个card负责输入物品名称、重量、价格

    3)第三个card显示结果

    算法分析

    本算法的关键是建立递归公式:m[i][j],m[n][j]

    m(i,j)= max{m(i+1,j),m(i+1,j-wi)+vi} j>=wi

    m[i][j]=

    m(i+1,j) 0=

    m(n,j)= vn j>wi

    m[i][j]=

    0=

    算法的主要思路就是将这个公式程序化,所以说数学建模很重要。在这里我觉得最精华的倒不是算法实现,最重要的有两点:一、动态规划法的思维方式,这种解题方式可以说是递归迭代,也可以认为是建了一个表去记录已经完成的运算成果以方便后边使用,避免重复运算。二、是用一种间接的方式保存被选中的物品,也就是这个表(m(i,j)),没有这个表就没有这个算法。

    程序总结

    通过完成此次试验,对动态规划法感慨良多。0-1背包问题的本质就是判断一个物品该不该放到背包里,然而这种判断还依赖于其他物品的选择,比较方便的方法就是穷举法,判断所有可能的状况,但这样的效率就太低了。解决一问题总有一个量来衡量解决这个问题所需要做的最少工作,编程的一个目标就是如何是计算机的效率更好的逼近这个量。研究穷举法我们会发现有很多重复的运算,优化穷举法的重要思路就是利用动态规划法的思想:利用已有的成果以避免重复运算,未进行的运算可以以已进行的运算为基础。因此我们必须有一种信息的表示方式来说明这个运算已经进行过了,反映到数学上就是发现运算之间的迭代关系。

    我们再从另一个角度去理解。吃饭要一口一口的吃,解决问题的一个重要方法就是缩小问题规模。如何缩小问题规模是个大学问,我们解决问题一般都有两种方法论——递推和递归,递推在这里很明显需要大量的回溯,或者直接就是低效率的穷举法。如果从递归方面看,我们先假设一个最优的结果,然后再看背包容量减少后的最优结果,这样一直迭代。算法的设计是最费脑筋的,但是查看一个优秀的算法非常有助于培养人们灵活的思维方式。

    最短路径问题(LJ)

    需求分析

    为用户提供一种输入手段获得一个无向图(或邻接矩阵),出发点和目的地,通过一定算法得到出发点到目的地的最短路径,显示给用户。

    概要设计

    三、详细设计

    数据类

    结点类Node

    此类负责记录结点信息:坐标(x,y),结点名称,结点序号

    边类

    此类负责记录结点之间连线的信息:起点序号,终点序号,起点和终点的距离

    我们在用户输入界面中建立两个向量对象,分别

    展开全文
  • 该代码是我上数据结构实训课所做的,适合不会的学生下载,可以应付一下实训周。希望对你有帮助。
  • 数据结构实训总结(900字) 这次课程设计的心得体会通过实习我的收获如下1巩固和加深了对数据结构的理解提高综合运用本课程所学知识的能力2培养了我选用参考书查阅手册及文献资料的能力培养独立思考深入研究分析问题...
  • 数据结构实训代码。 纯属学生式的创作,互相学习。
  • 数据结构实训代码C语言版 跟大家分享一下!欢迎大家来下载!
  • 数据结构实训之敢死队问题.cpp 敢死队问题.cpp
  • 数据结构实训.doc

    2020-05-01 23:07:07
    高职学院 计算机专业类 课 程 设 计 报 告 2012 -2013学年第1学期 课程设计类型数据结构 题目栈+串+队列+线性表+后缀表达式求值 学号 姓名 专业计算机应用技术 指导教师 课程设计日期2012.12.17~2012.12.21 高职学院...
  • 2017年1月数据结构实训总结

    千次阅读 2017-01-12 17:59:45
    今天进行了数据结构实训的答辩,心里感慨万千。  本次数据结构实训,从3号开始,到现在,确实学到了新的东西,2号拿到项目时,我的表情一定很好看,这么难,还要求让用可视化界面,我天天在实验室怼算法,并没有...

       今天进行了数据结构实训的答辩,心里感慨万千。

       本次数据结构实训,从3号开始,到现在,确实学到了新的东西,2号拿到项目时,我的表情一定很好看,这么难,还要求让用可视化界面,我天天在实验室怼算法,并没有什么项目经验,有点优势的也就是数据结构了,可视化什么的更是没有接触过,我心中在犯难。

    第一天学习了c#,毕竟要可视化,但是发现没有编译环境,我心中@#¥%……&*,(其实是有的,在机房的XP系统里有VS2010,可我当时并不知晓)然后问了巧姐,巧姐说可以学习c++的MFC,虽说MFC已经落后了,但是他的框架结构依旧是最先进的,然后,我就开始了我的漫漫MFC之路,前四天,每天晚上3点多睡,7点起,每天都困成dog。但一直在强撑,第五天,我发现好像这两天的学习没有白费,我发现了MFC的有趣的地方,我兴致冲冲的去怼了个员工信息管理系统,竟然成功了,然后开始写代码。这时,开发神突然给我说代码好简单。。。。

    哪里简单!@#¥……*,这就是我心中所想,他说先给我打个程序框架,我说行,一个下午,他可能兴致来了,竟然实现了六个功能,我心中!¥%……&*()—。—,说好的框架呢,怎么直接上代码了,而且我们只有八个功能,有个下午六个,这时要闹哪样。。。仔细看了看,他的MFC学的比我浅,而且好像理解错了我们的项目要求,我心中@#¥……&*。我给他说,他说不用改,好吧,最后他说服我了。

    我让他把最后两个功能写完(我是组长),他竟然开始咸鱼化,死活不写,没有办法,”老娘”亲自上阵,完成了最后两个功能,至此,ERP生产管理系统的1.0版本出来了,我心想,有点太简单了,就加了第九个功能,用户管理,并且基本用上了我学的所有知识,朕甚是满意。

    数据结构在这次实训里占分很重要,我就开始加数据结构,强行在用户管理界面里怼了一个字典树,强行在进场管理里怼了一个归并排序和二分查找,我就开始咸鱼,因为剩下的除了外委加工与管理功能都是我开发神写的,然后我开发神咸鱼的更彻底,一个都没加。。。我@#¥%……&*,

    慢慢的我又加了点数据结构,比较简单的,因为要分给组员功能。本想怼个比较高级的数据结构,然后我开发神说够了,我也就没有加。

    今天下午答辩,我说字典树老师问我是什么。。。。。我说是一个26叉树,然后她可能被我唬住了,给了我个B+(今天下午最高B+,明天优秀答辩),然后我就暗自高兴,到我组员,今天他们不知道咋了,被答辩老师吓到了,竟然都没答好,我心中!@#¥……*()。答辩老师这么严快气死我了。

    明天就要进行优秀答辩了,我们组肯定没戏,试试个人答辩吧,难为我这么大年纪了还要早起。。。

    展开全文
  • 实验报告 课程名称 数据结构 实验项目 哈希查找 实验地点 专业班级 学号 170731063 学生姓名 指导教师 黄永来 年 月 日 七实验评价 七实验评价 学生实验须知 一实验前的准备 1实验前必须充分预习明确实验目的和要求...
  • 1.学生管理系统 2.数据的传输 3.药品销售统计问题 4.医院选址问题 5.数据的传输 (可能因能力问题有部分bug哦,介意勿扰)
  • 这次的程序设计主要是校园导游系统,可以查看校园全景图,可以查看景点的信息,道路也分为人行道和车行道,还可以查找两景点间的最短路径和所有路径,还可以根据想去看的所有景点推荐一个最佳路径。...
  • 数据结构实训题目:一、图书借阅管理系统二、 学生成绩管理系统(B)
  • 数据结构用c语言实现停车场的功能,在机房32位电脑Linux下完成
  • 15 个题目同一个班上做同一个题目的人数最多 3 个每人必须独立完成 题目一停车场模拟程序 题目二杂货店排队模拟程序 如果有朋友正在排队则可以插队 题目三哈希表存储的电话号码查询 基本要求 设每个记录有以下数据项...
  • 试验一 线性表 试验要求 掌握数据结构中线性表基础概念 熟练掌握线性表基础操作创建插入删除查找输出求长度及合并并运算在次序存放结构上试验 熟练掌握链表多种操作和应用 试验内容 编写一个函数从一个给定次序表A中...
  • 题目一停车场模拟程序 题目二杂货店排队模拟程序 如果有朋友正在排队则可以插队 题目三哈希表存储的电话号码查询 基本要求 设每个记录有以下数据项用户名电话地址 从键盘输入各记录以电话号码为关键字建立哈希表 ...
  • 老早之前做的一个关于家谱的数据结构实训,现在给大家开放一看,增加了一个显示全部家谱的功能,想要源代码文件和可执行文件,可以点我的头像,然后点资源就可以找到了。 实训1.cpp #include <iostream&...

    老早之前做的一个关于家谱的数据结构实训,现在给大家开放一看,增加了一个显示全部家谱的功能,想要源代码文件和可执行文件,可以点我的头像,然后点资源就可以找到了。

    实训1.cpp

    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #include <conio.h>
    #define MAX 10
    typedef struct node//定义data存储结构,存放个人信息
    {       char name[MAX]; //姓名
            char sex;//性别
            int generation;//代
    }node;
    typedef struct treenode//创建结构体
    {
            struct node l; //家谱中直系家属
            struct treenode *brother;//用来指向兄弟
            struct treenode *child;//用来指向孩子
    }treenode;
    void screen();
    using namespace std;
    
    
    template<class T>
    T fun(T x)
    {
        if(x!=2)
            throw x;
        else
            return x;
    }
    treenode *root; //root是指向结构体treenode的指针
    
    
    
    treenode *search(treenode *p,char ch[])  
    {
        treenode *q;
         if(p==NULL) return NULL;//没有家谱,头指针下为空
         if(strcmpi(p->l.name,ch)==0)//比较姓名,看是否重名或是否存在
              return p;//家谱不为空,头指针下有这个人
         if(p->brother)
        {
            //递归过程
                q=search(p->brother,ch);//在兄弟中找
                if(q)
                return q;//找到
        }
         if(p->child)
        {
                q=search(p->child,ch);//在孩子中找
                if(q!=NULL)
                return q; //找到
        }
          return NULL;//没有找到
    }
     
    
    int generation(treenode *p,char ch[]) //获得搜索到的成员的代的返回值
    {
        treenode *q;
        if(p==NULL)
        return 0;
        if(strcmpi(p->l.name,ch)==0) //比较姓名,看是否重名或是否存在
        return p->l.generation;//家谱不为空,头指针下有这个人
        if(p->brother)
        {
              q=search(p->brother,ch);//在兄弟中找
              if(q)
              return q->l.generation;//找到
        }
        if(p->child)
        {
              q=search(p->child,ch);//在孩子中找
              if(q!=NULL)
              return q->l.generation; //找到
        }
                return 0;
    }
    
    void children(treenode *p,char b[],char c,int d)//建立家谱孩子结点,创建结点并对l赋值保存
    {
     
        int i;
        for(i=0;i<MAX;i++)
        p->l.name[i]=b[i];
        p->l.sex=c;
        p->l.generation=d;
    }
    
    void output(treenode *n) //搜索到数据的输出
    {
        treenode *t=NULL;
        printf("此人姓名:%s 性别%c 为第%d代\n",n->l.name,n->l.sex,n->l.generation);
        printf("\n");
        printf("此人的子女:"); //子女输出
        if(n->child==NULL)
        {
             printf("此人无子女!");
        }
        else
        {
            if(n->child->brother==NULL)
           {
             printf("姓名:%s 性别:%c\t",n->child->l.name,n->child->l.sex);
           }
            else
           {
             printf("姓名:%s 性别:%c\t",n->child->l.name,n->child->l.sex);
             t=n->child->brother;
             while(t!=NULL)
             {
                printf("姓名:%s 性别:%c\t",t->l.name,t->l.sex);
                t=t->brother;
             }
            }
        }
        printf("\n");
        printf("此人的同辈家庭成员:"); //同辈输出
        if(n->brother==NULL)
        {
            printf("此人无同辈家庭成员!");
        }
        else
        {
            if(n->brother->brother==NULL)
            {
                printf("姓名:%s 性别:%c\t",n->brother->l.name,n->brother->l.sex);
            }
            else
            {
                printf("姓名:%s 性别:%c\t",n->brother->l.name,n->brother->l.sex);
                t=n->brother->brother;
                while(t!=NULL)
                {
                    printf("姓名:%s 性别:%c\t",t->l.name,t->l.sex);
                    t=t->brother;
                }
     
     
            }
     
        }
    }
    
    void InitTree() //初始化(创建)
    {
        system("cls");
        //system("color 4f");
     
        cout<<endl<<endl<<endl<<endl;
        cout<<"                   ____________________________________________"<<endl;
        cout<<"                   >                                          <"<<endl;
        cout<<"                   >           现在开始初始化家族族谱         <"<<endl;
        cout<<"                   >                                          <"<<endl;
        cout<<"                   ____________________________________________"<<endl;
        cout<<endl<<endl<<endl;
        int a;
        char b[MAX],c;
        printf(" 请输入始祖的姓名和性别:");
        free(root);
        root=(treenode *)malloc(sizeof(treenode)); 
                                                
        scanf("%s %c",&b,&c);//输入姓名,性别
        while(c!='x'&&c!='n')
        {
            try
            {
                fun(c);
            }
            catch(...)
            {
                cout<<"输入性别有误!请重新输入!(女士:n;先生:x):"<<endl;
            }
            scanf("%s %c",&b,&c);//输入姓名,性别
        }
     
        a=1;//定义该祖先为第一代人
        root->child=NULL; //清空左右孩子
        root->brother=NULL;
        children(root,b,c,a);//存入结构
        printf("家谱初始化成功!\n");
        /*printf("\n按任意键返回主菜单..\n");
        getchar();*/
        system("pause");
        system("cls");
        screen();
    }
    
    void Add() //添加
    {
        system("cls");
        //system("color 4f");
        int a;
        cout<<endl<<endl<<endl<<endl;
        cout<<"                   ____________________________________________"<<endl;
        cout<<"                   >                                          <"<<endl;
        cout<<"                   >          现在开始添加家庭成员操作        <"<<endl;
        cout<<"                   >                                          <"<<endl;
        cout<<"                   ____________________________________________"<<endl;
        cout<<endl<<endl<<endl;
        treenode *n,*m,*t=NULL;
        char b[MAX],c,d[MAX];
        printf("请输入要添加子女的上辈家庭成员姓名:");
        scanf("%s",&d);
        n=search(root,d);
        a=generation(root,d);
        while(n==NULL) //判断是否有重名
        {
            printf("此人不在家谱内,请重新输入姓名:");
            scanf("%s",&d);
            n=search(root,d);
        }
        if(n->child==NULL)
        {
            printf(" 请输入所要添加家庭成员的姓名与性别:");
            scanf("%s %c",&b,&c);
             while(c!='x'&&c!='n')
        {
            try
            {
                fun(c);
            }
            catch(...)
            {
                cout<<"输入性别有误!请重新输入!(女士:n;先生:x):"<<endl;
            }
            scanf("%s %c",&b,&c);//输入姓名,性别
        }
            a++;
            m=search(root,b);//搜索族谱之中是否有与新添加成员重名的人,若有则添加失败
                if(m!=NULL)
                {
                    printf("出现重名了哦,添加失败!\n");
     
                }
                else
                {
                    n->child=(treenode *)malloc(sizeof(treenode));
                    n->child->brother=NULL;
                    n->child->child=NULL;
                    children(n->child,b,c,a);
                    printf("添加成功!\n");
                }
        }
        else//当该父辈之前已经有子女的时候,则此新添加的成员为添加的前一个孩子的兄弟
        {
            n=n->child;
            while(n->brother!=NULL) //添加另一个孩子
            n=n->brother;
            printf("请输入所要添加家庭成员的姓名与性别:");
            scanf("%s %c",&b,&c);
             while(c!='x'&&c!='n')
        {
            try
            {
                fun(c);
            }
            catch(...)
            {
                cout<<"输入性别有误!请重新输入!(女士:n;先生:x):"<<endl;
            }
            scanf("%s %c",&b,&c);//输入姓名,性别
        }
            a++;
            m=search(root,b);
            if(m!=NULL)
            printf("重名,添加失败!\n");
            else
            {
                t=(treenode *)malloc(sizeof(treenode));
                children(t,b,c,a);
                t->brother=NULL;
                t->child=NULL;
                n->brother=t;
                printf("添加成功!\n");
            }
        }
        printf("\n按任意键返回主菜单..\n");
        getch();
        system("cls");
        screen();
     
    }
    
    void Search() //查找
    {
        treenode *n;
        char d[MAX];
        printf("输入姓名,查找相关信息:");
        scanf("%s",&d);
        n=search(root,d);
        while(n==NULL)
        {
            printf("此人不存在,请再次输入:");
            scanf("%s",&d);
            n=search(root,d);
        }
        output(n);
        printf("\n");
        printf("\n按任意键返回主菜单..\n");
        getch();
        system("cls");
        screen();
    }
    
    void Change() //修改
    {
        char a[MAX],r[MAX],c;
        treenode *n;
        int i;
        printf("请输入要修改人的姓名:");
        scanf("%s",&a);
        n=search(root,a);
        while(n==NULL)
        {
             printf("此人不存在,请重新输入姓名:");
             scanf("%s",&a);
             n=search(root,a);
        }
        printf("此人存在,请输入新信息:");
        scanf("%s %c",&r,&c);
           while(c!='x'&&c!='n')
        {
            try
            {
                fun(c);
            }
            catch(...)
            {
                cout<<"输入性别有误!请重新输入!(女士:n;先生:x):"<<endl;
            }
            scanf("%s %c",&r,&c);//输入姓名,性别
        }
        for(i=0;i<MAX;i++)
        n->l.name[i]=r[i];
        n->l.sex=c;
        printf("修改成功!\n");
        printf("\n按任意键返回主菜单..\n");
        getch();
        system("cls");
        screen();
    }
    
     
    
    
    void outall(treenode *t, int i)
    {
    	for(int j=0;j<i;j++)
    	{
    		printf("\t");
    	}
    	printf("%s\n",t->l.name);
    	int c;
    	c=i+1;
    	if(t->child!=NULL)
    	{
    		outall(t->child,c);
    	}
    	if(t->brother!=NULL)
    	{
    		outall(t->brother,c);
    	}
    }
    
    void screen()//最初显示界面
    {
        system("cls");
        //system("color 4f");
        cout<<endl;
     
     
     
        cout<<endl;
        cout<<"                     ______________________________________"<<endl;
        cout<<"                     >>                                  <<"<<endl;
        cout<<"                     >>        欢迎进入家谱管理系统      <<"<<endl;
        cout<<"                     >>                                  <<"<<endl;
        cout<<"                     ______________________________________"<<endl;
        cout<<endl<<endl;
        cout<<"                                   1 添加成员"<<endl<<endl;
        cout<<"                                   2 查询个人信息"<<endl<<endl;
        cout<<"                                   3 修改信息"<<endl<<endl;
        cout<<"                                   4 创建族谱"<<endl<<endl;
    	cout<<"                                   5 显示族谱"<<endl<<endl;
        cout<<"                                   0 退出"<<endl<<endl;
        cout<<endl;
        int a;
        cout<<"                                 请输入数字:";
        cin>>a;
        while(!cin)
        {
            cout<<"                                 输入错误,请重新输入:";
            cin.sync();
            cin.clear();
            cin>>a;
        }
        while(a<1||a>6)
        {
            try
            {
                fun(a);
            }
            catch(...)
            {
                cout<<"                                 输入错误,请重新输入:";
            }
            cin>>a;
        }
        switch(a)
        {
     
        case 1:
            Add();
            system("pause");
            break;
        case 2:
            Search();
            system("pause");
            break;
        case 3:
            Change();
        case 4:
            InitTree();
            system("pause");
            break;
    	case 5:
    		outall(root,0);
        case 0:
          exit(0);
           break;
        }
    }
    
    

    实训2.cpp

    #include <stdio.h>
    #include <malloc.h>
    #include <string.h>
    #include <stdlib.h>
    #include <iostream>
    #include "windows.h"
    
    void screen();
    using namespace std;
    
    
    
    void proc()
    {
    	char buf[103];
    	memset(buf, ' ', sizeof(buf));
    	buf[0] = '[';
    	buf[101] = ']';
    	buf[102] = '\0';
    	int i = 0;
    	char index[6] = "-\\|/\0";
    	while (i <= 100)
    	{
    		buf[i] = '=';
    		printf("%s [%d%%][%c]\r", buf, i, index[i % 4]);
    		fflush(stdout);//刷新缓冲区
    		Sleep(66);
    		i++;
    	}
     
    	printf("\n");
    }
    //进度条
    int main()
    {
     
        proc();
    	screen();
        return 0;
     
    }

     

    展开全文
  • 34 //为顺序表分配空间,将所有数据初始化为init 35 mystable Assign(const intmaxlen,datatype init)36 {37 mystable temp;38 if((temp=(mystable)malloc(sizeof(struct Table)))!=NULL){//分配空间成功 39 temp->...

    1 #include"iostream"

    2 #include"stdio.h"

    3 #include"algorithm"

    4 #include"string"

    5 #include"string.h"

    6 #include"Stack"

    7 #include"queue"

    8 #include"vector"

    9 //顺序表ADT的定义10 //datatype的定义

    11 #ifndef datatype12 #define datatype NODE

    13 #define _ERROR NULL

    14 #endif

    15 FILE* rfile=fopen("E:\\read5.txt","r");16 FILE* wfile=fopen("E:\\write5.txt","w");17 //树结点的定义

    18 structTnode{19 struct Tnode *lchild;20 struct Tnode *rchild;21 char* data;//data用于保存节点信息,类型为字符串

    22 };23 typedef struct Tnode *Bitree;24 typedef struct Tnode *NODE;25 struct Table{ //为了定义栈

    26 datatype*Table_head;27 intLength;28 intMax_Length;29 };30 typedef struct Table*mystable;31

    32 //栈ADT的定义

    33 typedef struct Table*mystack;34 //为顺序表分配空间,将所有数据初始化为init

    35 mystable Assign(const intmaxlen,datatype init)36 {37 mystable temp;38 if((temp=(mystable)malloc(sizeof(struct Table)))!=NULL){//分配空间成功

    39 temp->Max_Length =maxlen;40 temp->Length=0;41 if((temp->Table_head=(datatype *)malloc(sizeof(datatype)*maxlen))!=NULL)42 for(int i=0;iTable_head+i)=init;44 else

    45 returnNULL;46 returntemp;47 }48 returnNULL;49 }50

    51 //判断表是否为空

    52 int isEmpty(constmystable table)53 {54 if (table==NULL)55 return -1;56 if(table->Length == 0)57 return 1;58 return 0;59 }60

    61 //判断表是否为满

    62 int isFull(constmystable table)63 {64 if (table==NULL)65 return -1;66 if(table->Length == table->Max_Length)67 return 1;68 return 0;69 }70

    71 //获取position位置的数据

    72 datatype get(const mystable table,intposition)73 {74 if (position>table->Length-1 || position<0)75 return_ERROR;76 return *(table->Table_head +position);77 }78

    79 //获取表长

    80 int getLength(constmystable table)81 {82 if (table==NULL)83 return -1;84 return table->Length;85 }86

    87 //从表中删除一个数据

    88 int Remove(const mystable table,intposition)89 {90 int i=0;91 if(table==NULL)92 return -1;93 if(position>table->Length-1 || position<0)94 return 0;95 for(i=position;iLength-1;i++)96 *(table->Table_head+i)=*(table->Table_head+(i+1));97 table->Length--;98 return 1;99 }100

    101 //插入一个数据到position位置

    102 int Insert(mystable table,intposition,datatype data)103 {104 int i=0;105 if(table==NULL)106 return -1;107 if(position>table->Length || position<0)108 return 0;109 if(isFull(table)==0){110 for(i=table->Length;i>position;i--)111 *(table->Table_head+i)=*(table->Table_head+(i-1));112 *(table->Table_head+i)=data;113 table->Length++;114 }else{115 mystable temp;116 if((temp=(mystable)malloc(sizeof(struct Table)))==NULL)117 return -1;118 if((temp->Table_head=(datatype*) malloc(sizeof(datatype)*(table->Max_Length+1)))==NULL)119 return -1;120 temp->Length=table->Max_Length+1;121 temp->Max_Length=table->Max_Length+1;122 for(i=0;iTable_head+i)=*(table->Table_head+i);124 *(temp->Table_head+i)=data;125 for(i++;iLength;i++)126 *(temp->Table_head+i)=*(table->Table_head+(i-1));127 free(table->Table_head);128 free(table);129 table=temp;130 }131 return 1;132 }133

    134 //释放表占用的空间

    135 int del(constmystable table)136 {137 free(table->Table_head);138 free(table);139 return 1;140 }141 //在表的最后插入一个数据

    142 int add(constmystable table,datatype x)143 {144 return Insert(table,table->Length,x);145 }146 //初始化栈,分配空间

    147 mystack initial()148 {149 return Assign(100,0);150 }151

    152 //从栈中弹出一个数据

    153 datatype pop(mystack Stack)154 {155 if(Stack==NULL)156 return_ERROR;157 if(isEmpty(Stack))158 return_ERROR;159 datatype data;160 data=get(Stack,Stack->Length-1);161 Remove(Stack,Stack->Length-1);162 returndata;163 }164

    165 //返回栈顶的数据但不弹出

    166 datatype peek(mystack Stack)167 {168 if(Stack==NULL)169 return_ERROR;170 if(isEmpty(Stack))171 return_ERROR;172 datatype data;173 data=get(Stack,Stack->Length-1);174 returndata;175 }176

    177 //向栈中压入数据

    178 intpush(mystack Stack,datatype x)179 {180 return Insert(Stack,Stack->Length,x);181 }182

    183

    184 //分配一个新的树节点

    185 NODE newNode(char*data)186 {187 NODE temp=(NODE)malloc(sizeof(structTnode));188 if(temp==NULL)189 returnNULL;190 temp->lchild=NULL;191 temp->rchild=NULL;192 temp->data=data;193 returntemp;194 }195

    196 //字符串转化为中缀顺序表,这是本实验的核心代码

    197 mystable char_to_infix(charex[])198 {199 int length=strlen(ex);200 mystable infix=Assign(length,NULL);201 char*temp;202 for (int i = 0; i < length; i++) {203 if ((ex[i] >= '0' && ex[i] <= '9') || ex[i] == '.') {204 //若是数字字符则查询直到遇到一个不是数字的字符

    205 int Count=0;206 for(int j=i;(ex[j] >= '0' && ex[j] <= '9') || ex[j] == '.';j++,Count++);207 temp=(char *)malloc(sizeof(char)*(Count+1));208 for(int j=0;j

    222 //中缀表达式转化为后缀表达式

    223 mystable infix_to_postfix(mystable infix)224 {225 mystack Stack=initial();226 mystable postfix=Assign(getLength(infix),NULL);227 for (int i = 0; i < getLength(infix); i++) {228 charopF,opS;229 opF=get(infix,i)->data[0];230 if ((opF>='0' && opF<='9') || opF=='.' || (opF>='a' && opF<='z'))231 //数字则直接压入后缀表达式

    232 add(postfix,get(infix,i));233 else{234 if (getLength(Stack) == 0) {235 push(Stack,get(infix,i));236 } else if (opF == '(') {237 push(Stack,get(infix,i));238 } else if (opF == ')') {239 //遇到右括号,将栈中的数据依次弹出,直到遇到左括号

    240 do{241 opS = peek(Stack)->data[0];242 if (opS != '(')243 add(postfix,pop(Stack));244 else

    245 pop(Stack);246 } while (opS != '(');247 } else{248 //比较优先级,若优先级高于栈顶元素则压入栈,否则弹出

    249 do{250 opS = peek(Stack)->data[0];251 intspriority,fpriority;252 switch(opS){253 //设置优先级

    254 case '+':spriority=4;break;255 case '-':spriority=4;break;256 case '*':spriority=3;break;257 case '/':spriority=3;break;258 case '^':spriority=2;break;259 case '(':spriority=7;break;260 }261 switch(opF){262 case '+':fpriority=4;break;263 case '-':fpriority=4;break;264 case '*':fpriority=3;break;265 case '/':fpriority=3;break;266 case '^':fpriority=2;break;267 case '(':spriority=7;break;268 }269 if (fpriority >=spriority)270 add(postfix,pop(Stack));271 else

    272 break;273 } while (getLength(Stack) != 0);274 push(Stack,get(infix,i));275 }276 }277 }278 while (getLength(Stack) != 0)279 add(postfix,pop(Stack));280 //释放括号占用的内存

    281 for(int i=0;idata[0]=='(' || temp->data[0]==')'){284 free(temp->data);285 free(temp);286 }287 }288 //释放栈占用的内存

    289 del(Stack);290 //释放掉前缀表达式占用的内存

    291 del(infix);292 returnpostfix;293 }294

    295 //生成表达式树

    296 Bitree postfix_to_binarytree(mystable postfix)297 {298 mystack Stack=initial();299 for (int i = 0; i < getLength(postfix); i++) {300 charname;301 name=get(postfix,i)->data[0];302 if ((name>='0' && name<='9') || name=='.' || (name>='a' && name<='z')){303 push(Stack,get(postfix,i));304 }else{305 NODE parent=get(postfix,i);306 NODE lchild,rchild;307 //从栈中弹出操作数,将运算符节点的两个儿子指针指向操作数结点

    308 if(getLength(Stack)!=0){309 rchild=pop(Stack);310 parent->rchild=rchild;311 }312 if(getLength(Stack)!=0){313 lchild=pop(Stack);314 parent->lchild=lchild;315 }316 push(Stack,parent);317 }318 }319 if(getLength(Stack)!=1){320 returnNULL;321 }else{322 NODE result=pop(Stack);323 //释放内存

    324 free(Stack);325 free(postfix);326 returnresult;327 }328 }329

    330 //打印前缀表达式

    331 voidprint_prefix(Bitree node)332 {333 if(node==NULL)334 return;335 fprintf(wfile,"%s",node->data);336 if(node->lchild!=NULL)337 print_prefix(node->lchild);338 if(node->rchild!=NULL)339 print_prefix(node->rchild);340 }341

    342 //打印后缀表达式

    343 voidprint_postfix(Bitree node)344 {345 if(node==NULL)346 return;347 if(node->lchild!=NULL)348 print_postfix(node->lchild);349 if(node->rchild!=NULL)350 print_postfix(node->rchild);351 fprintf(wfile,"%s",node->data);352 }353

    354

    355

    356 //递归打印叶节点递归函数入口

    357 void _print_path_with_recursion(Bitree tree,NODE path[],intdepth)358 {359 if(tree==NULL)360 return;361 //若为叶节点则打印路径

    362 if(tree->lchild==NULL && tree->rchild==NULL){363 fprintf(wfile,"%s : %s",tree->data,tree->data);364 for(int i=depth-1;i>=0;i--)365 fprintf(wfile,"%s",path[i]->data);366 fprintf(wfile,"%s\n","");367 }368 if(tree->lchild!=NULL){369 path[depth]=tree;370 _print_path_with_recursion(tree->lchild,path,depth+1);371 }372 if(tree->rchild!=NULL){373 path[depth]=tree;374 _print_path_with_recursion(tree->rchild,path,depth+1);375 }376 }377

    378 //非递归打印叶节点

    379 voidprint_path_without_recursion(Bitree tree)380 {381 NODE curr=tree;382 NODE path[100];383 //存放深度的数组

    384 int depth[100];385 int top=0,curdepth=0;386

    387 mystack track=initial();388 do{389 if(curr!=NULL){390 if(curr->lchild==NULL && curr->rchild==NULL){391 fprintf(wfile,"%s : %s",curr->data,curr->data);392 for(int i=curdepth-1;i>=0;i--)393 fprintf(wfile,"%s",path[i]->data);394 fprintf(wfile,"%s\n","");395 //从栈中弹出下一个要访问的结点,并将当前深度更新为该结点深度

    396 curr=pop(track);397 curdepth=depth[--top];398 }else{399 path[curdepth]=curr;400 push(track,curr->rchild);401 depth[top++]=++curdepth;402 curr=curr->lchild;403 }404 }else{405 curr=pop(track);406 curdepth=depth[--top];407 }408 }while(curr!=NULL || getLength(track)!=0);409 }410 //递归打印叶节点主程序入口

    411 voidprint_path_with_recursion(Bitree tree)412 {413 NODE path[100];414 _print_path_with_recursion(tree,path,0);415 }416 intmain(){417 char ch[100];418 int icase=1;419 while(fscanf(rfile,"%s",ch),strcmp(ch,"no")!=0)//输入表达式

    420 {421 fprintf(wfile,"%s%d%s\n\n","案例 #",icase++,":");422 mystable infix=char_to_infix(ch);423 mystable postfix=infix_to_postfix(infix);424 Bitree root=postfix_to_binarytree(postfix);425 if(root==NULL)426 fprintf(wfile,"%s","输入有误!\n\n");427 else{428 fprintf(wfile,"%s","输出前缀表达式:");429 print_prefix(root);//输出前缀式

    430 fprintf(wfile,"%s\n\n","");431 fprintf(wfile,"%s","输出后缀表达式:");432 print_postfix(root);//输出后缀式2

    433 fprintf(wfile,"%s\n\n","");434 fprintf(wfile,"%s\n","用递归打印从根节点到叶子节点的路径:");435 print_path_with_recursion(root);436 fprintf(wfile,"%s\n","");437 fprintf(wfile,"%s\n","用非递归打印从根节点到叶子节点的路径:");438 print_path_without_recursion(root);439 }440 }441 return 0;442 }

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,049
精华内容 419
关键字:

数据结构实训

数据结构 订阅