精华内容
下载资源
问答
  • 哈尔滨工业大学数据结构与算法2012年的期末考试试题以及答案,供备考的同学们使用。
  • 哈工大数据结构与算法全部实验汇总,包括代码和实验报告,供给广大学弟学妹。学艺不精,有不足的地方希望大家多多包涵,进行改进。
  • 哈尔滨工业大学数据结构与算法试卷 1.深(高)度为 6(根的层次为 1)的完全二叉树至少有( )结点。 A. 64 B.32 C.31 D.63 2.若具有 n 个结点、k 条边的非连通无向图是森林(n>k),则该森林中必有( )棵树。 ...
  • 实验项目:查找结构的实验比较 实验题目:BST 查找结构与折半查找方法的实现与实验比较 实验内容: 本实验要求编写程序实现 BST 存储结构的建立(插入)、删除、查找和排 序算法;实现折半查找算法;比较 BST 查找...
  • 国家精品课程网上有相应的视频教程,这是对应的ppt讲义,分别由刘杨、李秀坤、张岩等几位老师轮流授课,个人觉得是数据结构讲的比较好的
  • 该源码用于学习交流,给没有思路的同学提供一些思路,坚决抵制抄袭。源码用clion写的,如果用其他集成开发环境运行可能需要改一下txt文档的相对路径,到时自行百度。
  • 实验项目:线性表的链式存储结构与应用 实验题目:一元多项式计算器 实验内容: 设计线性表的动态或者静态链式存储结构,并实现一个一元多项式的计算器。 实验要求: 以动态或者静态链表存储一元多项式,在此基础上...
  • 实验项目:图型结构的建立与搜索 实验题目:图的存储结构的建立与搜索 实验内容 1: 图的搜索(遍历)算法是图型结构相关算法的基础,本实验要求编写程序 演示无向图典型存储结构的建立和搜索(遍历)过程。 实验...
  • 哈工大数据结构
  • 实验项目:树型结构的建立、遍历和应用 实验题目:二叉树存储结构的建立、遍历和应用 实验内容: 树型结构的遍历是树型结构算法的基础,本实验要求编写程序演示二叉树 的存储结构的建立方法、遍历过程以及应用。 ...
  • 排序方法是数据处理的最基本和最重要的操作。其目的是将一组“无序”的 记录序列调整为“有序”的记录序列。 实验题目:排序方法的实现与实验比较 实验内容: 实现一组经典的排序算法,通过实验数据的设计,考察...
  • 第二章 算法及其性能分析 1. 算法是 2. 算法的五个基本特征是 和 3. 算法的正确性的含义是 4. 一个算法的时间复杂性是 的一个函数这个函数表示该算 的 重复执行的次数 5. 你是怎样理解算法的时间复杂性的算法的时间...
  • 哈工大张岩老师班级的实验,第一个,算术表达式求值,第二个,树,第三个,图;里面有报告。学弟学妹们参考吧!乐学网查出抄袭本人概不负责,特此声明。
  • 哈工大数据结构课件

    2013-10-16 10:57:52
    哈工大数据结构课件,和大家分享一下。讲得都挺好的,感谢老师。
  • 图形结构及其应用
  • 哈工大历年数据结构试卷,配有详细答案,作为测验或者复习等都是不错的选择,均为pdf格式
  • 哈工大 计算机专业 数据结构 期末试题 2003-2005
  • 2020年秋哈工大数据结构作业3树形结构及其应用源代码
  • 文件是网盘链接地址,2018.7.4上传,链接一直可用 本套视频为数据结构与算法视频教程、哈工大_数据结构与算法
  • 哈工大数据结构13年期末试卷
  • 哈工大数据结构实验3比赛图,使用矩阵行列变换的思想做的,老师评价很好。
  • 哈工大2019秋数据结构期末试题

    千次阅读 多人点赞 2020-10-29 21:39:44
    虽然隔了一年,但是数据结构题目题型我还是记得的。 期末试题总分60 1.选择题 十个还是十五个来着,一个一分 考察:算法复杂度 比如经典的Dijkstra算法、Floyd算法,十大排序算法。 选择题考察的很细,涉及到二叉树的...

    虽然隔了一年,但是数据结构题目题型我还是记得的。

    期末试题总分60
    选择10分+填空10分+简答25分+算法设计25分

    1.选择题

    十个,一个一分
    考察

    选择题考察的很细,涉及到二叉树的算法、图的算法的具体某一个步骤。 比如经典的Dijkstra算法、Floyd算法,十大排序算法。强烈建议搞懂每个算法的实现原理和具体的实现过程。!!!

    我清楚的记得,有一道选择题,给了四个排序算法,问哪个算法是稳定的?

    在这里插入图片描述

    2.填空题

    10道,一道一分。
    填空题同选择题一样,也考的特别的细。
    但是都不难,考的很基础。

    3.简答题(25分)

    简答题总共三道题目,主要考察查找(平衡树、散列)、堆、线性表等知识。

    第一题内容是给出一个二叉搜索树的后序遍历,问能不能确定这个二叉树。(很简单,举例说明即可)

    第二题内容分为两个小问,第一个小问是根据快递单号确定快递存放的货柜,方便查找,体现了什么思想,第二问是已知货柜号和快递单号,在取快递时,可以采用哪些策略来快速查找到快递。

    第三题内容是银行系统中,每个客户对应一个权限,要求银行每一次可以选取一个权重最高或者权重最低的客户来服务,问采用什么数据结构?怎么实现它?(显而易见是堆 了,但是如果你只写一个字堆你觉得老师会给你几分?是不是还得写个伪代码啥的说明一下算法的实现?)

    4.算法设计题(25分)

    这部分题要求自行设计数据结构,给出c/c++/java语言代码,分析复杂度。个人觉得本部分题最拉开差距。

    第一题是给出中序线索二叉树的一个节点p,设计一个算法,求它的前驱节点p$。(赶快去看看线索二叉树!)

    第二题是给出两个升学排列的数组A,B,长度分别为m,n,设计一个算法,输入一个数k,返回数组A,B中第k小的元素。(就双指针走呗,都已经是升学数组了)

    第三题是给出一个有向图G,设计一个算法,判断任意两个顶点是否连通。(注意是有向图,我tm当时做的时候搞成了无向图。这道题就手写广度优先遍历呗,但是注意要从两个顶点都得开始遍历,笔者的痛。)[15分]

    建议大家把二叉树的遍历、图的遍历、搜索算法、排序算法都熟悉熟悉,没准又让你手写课本学习的算法呢。

    所以,总的来说就是熟悉PPT,熟悉学过的算法和数据结构。

    还有就是实验分基本你写了验收了就是满分。

    数据结构90分不难,只要你实验搞懂了,PPT搞懂了,刷刷纸张记忆的题,绝对没问题的。(95分也不是问题)

    感谢一位同学的分享,之前更新的数据结构题目有点偏差,这次保证是最全最正确的哈工大2019秋数据结构期末试题。也希望他早日实现自己的梦想!

    5.其他年份的期末考试原题

    哈工大2012秋数据结构期末试题(含答案)
    哈工大2013秋数据结构期末试题(含答案)
    哈工大2015秋数据结构期末试题(含答案)
    哈工大2017秋数据结构期末试题(含答案)
    (哈工大2016年数据结构期末题及答案由于版权原因不能发到博客上,需要的私聊我)

    找到了其他年份的题接着更新
    需要pdf的私聊我

    展开全文
  • 爱课程上面的PPT,从校内网站下载,国家精品课程网上有相应的视频教程,这是对应的ppt讲义,分别由刘杨、李秀坤、张岩等几位老师轮流授课。
  • 文 彦 考 研让 | 梦想 | 有迹可循老师简介 逐勋师兄,2015年以专业课分数117的成绩考入哈尔滨工业大学计算机学院,连续3年从事哈工大计算机专业课考研辅导工作,精通计算机系统基础(csapp),计算机网络和数据结构,...
    a176428a3260b550a0f7b7757ff41367.png

    文 彦 考 研

    让 | 梦想 | 有迹可循

    老师简介

    59c1984d63aadbab1c5ae5725601c9bd.png

    逐勋师兄,2015年以专业课分数117的成绩考入哈尔滨工业大学计算机学院,连续3年从事哈工大计算机专业课考研辅导工作,精通计算机系统基础(csapp),计算机网络和数据结构,研究哈工大历年考研真题,有自己独到的解题思路和方法。

    文章 · 概要

    01  考情分析与院校专业介绍

    02  复习规划【参考书目,各部分重点】

    03  课程介绍

    04  真题试练

    01  院校/专业 · 介绍

    地 · 位

    哈尔滨工业大学,由工业和信息化部直属、中央直管副部级建制。国家首批世界一流大学建设高校A类、985工程、211工程,九校联盟。2017年入选“双一流”建设A类高校名单。

    计算机专业是哈尔滨工业大学的王牌专业,其就业生的质量和薪资一直名列前茅。

    硬件 · 设施

    本部包括社会计算与信息检索实验室,海量数据计算研究中心,容错与移动计算研究中心等实验室,深圳校区包括计算机应用实验室、智能计算研究中心、企业职能研究中心等实验室。

    就业 · 去向

    普遍就业于华为、腾讯、阿里巴巴、头条、百度等互联网公司,年薪大多在20-40万。

    哈工大 · 20年分数线(实际)

    全国硕士生报名人数逐年递增,21年预计突破400万,哈工大分数线大多集中在320-360之间,由于20年专业课课改所以分数线较上年降低40分,同时复试通过率为101%,基本属于保过,吸引力较大。

    02  复习 · 规划

    哈尔滨工业大学854计算机专业基础综合共包含三门专业课:计算机系统、数据结构和计算机网络,分值分别为70,40,40分,下面对每门课逐个分析。

    计算机系统:

    分值和题型:

    包括20分选择题,10分填空题,10分问答题,30分设计题。

    参考书目推荐:

    深入理解计算机系统第三版,时间充足的同学也可以看一下袁春风老师的计算机系统基础,但是推荐看袁老师的书看到链接就可以了。

    各章节要点

    第一章计算机基本概念需要了解计算机系统的层析结构,程序生成与运行的基本原理与工作过程,计算机系统的分析评价方法。

    第二章信息表示与处理需要了解数据的存储,包括大端小端方式以及信息编码例如ASCII编码,另外要会对数据进行表示和运算,主要是原码、补码、反码和移码,以及对浮点数的学习,IEEE754浮点数表示法。

    第三章程序级及其表示需要对汇编指令做到会看会用,了解程序结构的机器级宝石,以及缓冲区溢出的原理和漏洞攻防。

    第四章处理器体系结构需要连接ISA的组成与设计,CISC和RISC的区别,深入理解流水线原理以及相应的计算题。

    答案

    点击下方查看更多

    第五章程序性能优化需要明白面向编译器的程序优化方法,面向CPU的性能优化方法。

    第六章存储器层次结构需要了解存储器局部性原理,以及不同类型的存储器的优点与缺点,另外要明白高速缓存技术以及基于存储器的程序优化技术。

    第七章链接要明白符号解析和重定位,什么符号属于全局符号什么符号属于局部符号,哪些是强符号哪些是弱符号,如何根据绝对地址进行重定位,如何进行相对重定位。

    第八章异常控制流需要明白异常的分类和处理方式,明白fork函数,如何进行非本地跳转

    第九章虚拟存储器需要明白虚拟地址与物理地址的转换,动态存储器分配技术。

    数据结构

    参考书:廖明宏老师的数据结构和王道书籍。

    学习内容:

    *数据结构与算法的概念

    *时间复杂度和空间复杂度的计算

    *线性表的存储,单链表,循环链表等链表的特点

    *熟悉二叉树的运算和先序中序后序遍历,层次遍历,平衡二叉树的相关考点

    *图这部分要明白图的深度遍历和广度遍历,拓扑排序以及关键路径。

    *八大排序算法以及二叉查找树相关知识点要了解,选择题出题概率较高。

    计算机网络

    学习内容:

    *熟悉网络的分层结构,明白物理层带宽的相应计算,例如奈奎斯特定理。

    *数据链路层明白GBN协议,SR协议等,网络层需要明白ip地址划分,rip协议,ospf协议,dhcp协议等。

    *传输层需要明白TCP协议和UDP协议,最后的应用层明白DNS协议,邮件传输协议等考点。

    03  课程 · 安排· 真题试练

    时间 · 安排

    共60小时

    1.专业课进行第一轮的讲解:前34小时

    (计算机系统基础17个小时,数据结构9小时,计算机网络8小时)

    2.题目进行强化:15小时

    包括计算机统考408数据结构和计算机网络的真题,还有各大高校计算机系统基础相关的期末和考研真题精析

    3.冲刺押题:10小时

    01

    (统考2015)已知字符串S为‘abaabaabacacaabaabcc’,模式串t为‘abaabc’,采用KMP算法进行匹配,第一次出现‘失配’,i=j=5,则下次开始匹配时,i和j的值分别为(      )

    A. i=1,j=0

    C.i=5,j=2

    B.i=5,j=0 

    D.i=6,j=2

    答案

    点击下方空白处获得答案

    C

    02

    (哈工大2017)已知字符串S为‘ababcabcacbab’,模式串T为‘abcac’,若采用KMP算法进行模式匹配,则需要(  )遍匹配,能确定T是S的子串。

    A.1

    C.4

    B.3

    D.5

    答案

    点击下方空白处获得答案

    B

    上面两道题目都是对KMP算法的考察,通过分析可以发现哈工大考研复习可以结合408的真题,相辅相成。今天的分享就到这里啦~下期更精彩哦!

    21届考研初试辅导班招生进行中...

    大家有任何疑问,入群或

    8d4d0ff33c2f766f812cd1b0156fe076.png加老师微信,一对一咨询8d4d0ff33c2f766f812cd1b0156fe076.png

    ee8edebd23f3644334d2e90adb493905.png

    入群还可获取更多干货

    哈工大计算机考研QQ群

    7162d777cf1c1639befd634eb3848962.png

    官网/微博:文彦考研cb1f3a893ddb5d08a32b903f37f26533.png

    注:图片来源于网络,版权归原作者所有,侵删。

    点个“在看”会有对象806b734939c9c37c761d2393357b502b.png

    展开全文
  • 哈工大数据结构实验三——图形结构及其应用

    千次阅读 多人点赞 2020-11-03 11:21:14
    数据结构实验三目录0.实验要求1.实验思路1.1实现图的存储1.1.1 图的邻接矩阵存储1.1.2 使用图的邻接矩阵建立一个图1.1.3 图的邻接表存储1.1.4 使用图的邻接表建立一个图 0.实验要求 1.实验思路 1.1实现图的存储 ...

    0.实验要求

    在这里插入图片描述

    1.实验思路

    1.1实现图的存储

    1.1.1 图的邻接矩阵存储

    图的邻接矩阵存储就是,把图看成是一个二维矩阵,矩阵A[i][j]的值就表示节点i和节点j之间的边的权重,如果顶点i和顶点j之间没有边,则设置A[i][j] = 正无穷大。
    因此,用邻接矩阵的形式存储图的结构,我们需要以下三个信息

    1. 邻接矩阵
    2. 所有的顶点的信息
    3. 图的顶点个数和边的个数
    #include<iostream>
    #include<fstream>
    #include<queue>
    #include<stack>
    #define max 100
    typedef int data;//权重的数据类型 
    using namespace std;
    bool visited[max];
    int dfn[max];//顶点的先深编号 
    int count=1;
    //邻接矩阵的存储结构 
    typedef struct{
     int vertex[max];//邻接矩阵的顶点数组
     data edge[max][max];//邻接矩阵的边值 
     int n,e;//邻接矩阵的顶点和边的个数 
    }mygraph;

    看一个实例,假设边的权重为1表示两个顶点之间有边,边的权重为0表示两个顶点之间没有边。

    在这里插入图片描述

    1.1.2 使用图的邻接矩阵建立一个图

    1. 指定图的顶点的个数和边的个数
    2. 初始化邻接表和邻接矩阵
    3. 根据给定的顶点和顶点的权重改变邻接矩阵的值。 注意:对于无向图来说,邻接矩阵是对称的,所以如果顶点i , j之间权重为k,则A[i][j] = A[j][i] = k
    void CreateGraph(mygraph *G){// 创建邻接矩阵 
     int i,j,k,w;
        cout<<"输入顶点个数和边的个数"<<endl;
        cin>>G->n>>G->e;//输入顶点个数和边的个数;
        for(i=0;i<G->n;i++){
          G->vertex[i]=i;
       } 
       for(i=0;i<G->n ;i++)
         for(j=0;j<G->n ;j++)
             G->edge[i][j]=0;//初始化邻接矩阵 
       for(k=0;k<G->e;k++){
         cout<<"输入边(i,j)和权重w"<<endl;
         cin>>i>>j>>w;
         G->edge[i][j]=w;//输入边(i,j)和权重w 
         G->edge[j][i]=w;
     }
    }
    void wenjianCreateGraph(mygraph *G){// 从文件创建邻接矩阵 
        fstream in;
        in.open("tu1.txt");
        int i,j,k,w;
        in>>G->n>>G->e;//输入顶点个数和边的个数;
        for(i=0;i<G->n;i++){
          G->vertex[i]=i;
       } 
       for(i=0;i<G->n ;i++)
         for(j=0;j<G->n ;j++)
           G->edge[i][j]=0;//初始化邻接矩阵 
       for(k=0;k<G->e;k++){
         in>>i>>j>>w;
         G->edge[i][j]=w;//输入边(i,j)和权重w 
         G->edge[j][i]=w;
       }
       in.close();
    }

    算法时间复杂度:O(n^2+n+2e )//n个顶点初始化,n^2个边的初始化,输入无向图的2e条边
    算法空间复杂度:O(n^2+n )//存储n个顶点及n^2个边值信息

    void shuchugraph(mygraph *t){//打印邻接矩阵的信息 
       for(int i=0;i<t->n ;i++){
          cout<<"\t"<<i; 
      }
      cout<<endl;
      for(int i=0;i<t->n ;i++){
          cout<<i<<"\t";
        for(int j=0;j<t->n ;j++){
           if(t->edge[i][j]==0){
             cout<<"∞\t";
           }
           else
             cout<<t->edge[i][j]<<"\t";
        }
        cout<<endl;
     }
    }

    在这里插入图片描述

    1.1.3 图的邻接表存储

    图的邻接表存储,就是对于每个顶点v来说,和这个顶点v相连的所有邻接点构成一个线性表。

    我们需要把顶点分成两类,一类是主顶点,一类是和顶点链接的边顶点。

    对于每个主顶点,我们需要存储以下信息:

    1. 有一个指针域,指向的是和顶点v邻接的第一个顶点。
    2. 顶点的下标,指明了顶点的编号
    3. 一个标记布尔类型的值,标记这个顶点是否被访问过(用于图的遍历)
    typedef struct {//顶点表节点 
       int dingdian;//顶点表节点
       bool zouguo;//标记节点是否被访问过 
       Edgenode *firstedge;//边链表头指针 
    }Vertex;

    对于每一个边顶点,我们需要存储以下信息。

    1. 顶点下标
    2. 和主顶点邻接的边的权重
    3. 指向下一边表节点的指针
    typedef struct node{//边表节点 
      int xiabiao;//顶点下标
      data cost;/和主顶点邻接的边的权重
      struct node *next;//指向下一边表节点的指针 
    }Edgenode; 

    那么整个图就可以用一个主顶点数组来表示,同时需要指明图的边的个数和顶点的个数。

    typedef struct {//图的邻接表 
        Vertex vexlist[max];//顶点数组 
        int n,e;//顶点个数和边的个数 
    }adjgraph;

    看一个例子
    在这里插入图片描述

    1.1.4 使用图的邻接表建立一个图

    输入顶点个数和边的个数
    初始化顶点邻接表
    根据给定的邻接顶点i和j,创建边顶点p和q分别存储顶点i和j的信息,让主顶点i指向q,且让主顶点j指向边顶点q。

    void CreateadjGraph(adjgraph *G){// 创建邻接表
         int i,k,j;
         data weight;
         cout<<"请输入顶点个数和边的个数"<<endl; 
         cin>>G->n >>G->e ; 
        for(i=0;i<G->n;i++){
           G->vexlist[i].dingdian=i;
           G->vexlist[i].firstedge=NULL;//初始化邻接表 
     }
        for(k=0;k<G->e ;k++){
          cout<<"输入边(i,j)和权重w"<<endl;
          cin>>i>>j>>weight;
          Edgenode* p=new Edgenode;
          p->xiabiao =j;p->cost =weight; 
          p->next =G->vexlist[i].firstedge ;
          G->vexlist[i].firstedge =p;
          Edgenode* q=new Edgenode;
          q->xiabiao =i;q->cost =weight; 
          q->next =G->vexlist[j].firstedge ;
         G->vexlist[j].firstedge =q;
     }
    }
    void wenjianCreateadjGraph(adjgraph *G){// 从文件创建邻接表
          fstream in;
          in.open("tu2.txt");
          int i,k,j;
          data weight;
          in>>G->n >>G->e ; 
          for(i=0;i<G->n;i++){
             G->vexlist[i].dingdian=i;
             G->vexlist[i].firstedge=NULL;//初始化邻接表 
     }
         for(k=0;k<G->e ;k++){
             in>>i>>j>>weight;
             Edgenode* p=new Edgenode;
             p->xiabiao =j;p->cost =weight; 
    	 p->next =G->vexlist[i].firstedge ;
             G->vexlist[i].firstedge =p;
             Edgenode* q=new Edgenode;
             q->xiabiao =i;q->cost =weight; 
             q->next =G->vexlist[j].firstedge ;
            G->vexlist[j].firstedge =q;
     }
     	in.close();
    }
    void shuchuadjgraph(adjgraph *t){//打印邻接表 
        for(int i=0;i<t->n ;i++){
          cout<<i<<":\t";
          Edgenode *p;
          p=t->vexlist[i].firstedge;
          while(p!=NULL){
            cout<<p->xiabiao<<"\t";
            p=p->next ;
         }
          cout<<endl;  
       } 
    }

    1.2. 图的邻接矩阵和图的邻接表两种存储结构的转换

    1.2.1 图的邻接矩阵转向图的邻接表

    1. 思路很简单,先初始化邻接矩阵,根据顶点个数和边的个数。
    2. 然后遍历邻接矩阵,如果A[i][j] 不等于0 , 则表示顶点i 和 顶点j
      之间邻接,边权重为A[i][j],然后用之前讲过的邻接表创建图的方法来创建邻接表。
    void jzhuanhuanb(mygraph *G,adjgraph *T){//将邻接矩阵G转化为邻接表T 
         T->n=G->n ;//初始化邻接表 
         T->e =G->e;//初始化邻接表 
         for(int i=0;i<G->n;i++ ){//初始化邻接表
            T->vexlist[i].dingdian =i;
            T->vexlist[i].firstedge=NULL;
         }
         for(int j=0;j<G->n;j++){
            for(int k=0;k<G->n ;k++){
              if(G->edge[j][k]!=0){
                  Edgenode *p=new Edgenode;
                  p->xiabiao=G->vertex[k];//顶点赋值 
                  p->cost =G->edge[j][k];  //边权重赋值 
                  p->next =T->vexlist[j].firstedge  ;
                  T->vexlist[j].firstedge=p;
             }  
          }
        }  
    }

    在这里插入图片描述

    1.2.2 图的邻接表转向图的邻接矩阵

    思路同上,先初始化,然后遍历每个顶点的邻接顶点,然后给邻接矩阵赋值即可。

    void bzhuanhuanj(mygraph *G,adjgraph *T){//将邻接表转换为邻接矩阵
        Edgenode *p;
        G->n =T->n;//初始化邻接矩阵
        G->e =T->e ;//初始化邻接矩阵
        int i,j;
        for(i=0;i<G->n;i++){
           for( j=0;j<G->n;j++){
              G->edge[i][j]=0;//初始化邻接矩阵 
          }
         }
         for(int k=0;k<G->n;k++){
            p=T->vexlist[k].firstedge ;
            while(p!=NULL){
               G->edge[k][p->xiabiao]=p->cost;//将边权重赋值 
              p=p->next ;
          }
         }
    }

    在这里插入图片描述

    1.3 图的深度优先遍历

    1.3.1 邻接矩阵表示的图的深度优先遍历

    1.3.1.1 递归

    思路:借助一个标记数组,标记了每个顶点是否被访问过。

    1. 首先对每个顶点标记为未访问过。
    2. 然后对于顶点v,如果顶点v没有被访问过,则访问这个顶点,并且把这个顶点标记为访问过,然后递归的访问这个顶点邻接的顶点。
    3. 访问完顶点v的所有邻接的节点后,把森林的个数加1,然后再去访问没有访问过的顶点k,再转2.
    void DFSX(mygraph *G,int x){//辅助深度递归 (通过邻接矩阵)
        visited[x]=true;
        cout<<G->vertex[x]<<" ";
        for(int j=0;j<G->n;j++){
           if(!visited[j]&&G->edge[x][j]!=0)
              DFSX(G,G->vertex[j]);
        }
       }
    void diguishen(mygraph *G){    //邻接矩阵深度递归算法 
         for(int i=0;i<G->n;i++){//将每个节点标记为未访问过 
            visited[i]=false;
        }
         int count=1;//森林个数 
         for(int i=0;i<G->n;i++){
           if(!visited[i]){
             cout<<"森林"<<count++<<":"; 
             DFSX(G,i);
             cout<<endl;
         }  
        }
     }

    1.3.1.2 非递归

    一般对于所有的递归算法来说,要把它变成非递归算法,则要利用栈。
    算法原理:

    1. 首先对每个顶点标记为未访问过。
    2. 然后遍历所有的顶点,对于顶点v,如果顶点v没有被访问过,则访问这个顶点,并且把这个顶点标记为访问过,并且把这个顶点压入栈中。
    3. 当栈不为空时,取栈顶顶点t,然后访问所有和顶点t邻接的顶点x。如果顶点x没有被访问过,则访问这个顶点,并且把这个顶点标记为访问过,并且把这个顶点x压入栈中。然后再去访问顶点x邻接的所有顶点。
    4. 考察完顶点v所邻接的所有顶点之后,再去访问没有访问过的顶点。
    void feidiguishen2(mygraph *G){ //邻接矩阵深度非递归算法 
        for(int l=0;l<G->n ;l++)//将每个节点标记为未访问过 
           visited[l]=false;
        stack<int>s;
        int count=1;//森林个数 
         for(int j=0;j<G->n;j++){
           if(!visited[j]){
            cout<<"森林"<<count++<<":";
            visited[j]=true;
            s.push(j);
           cout<<G->vertex[j]<<" ";
           while(!s.empty() ){
             int t = s.top();
             bool flag = false;
             for(int k=0;k<G->n ;k++){
               if(G->edge[t][k]!=0){
                 if(!visited[k]){
                   visited[k]=true;
                   cout<<G->vertex[k]<<" ";
                   s.push(k);
                   flag = true;
                 break ;
              }
            }
        }
           if (flag == false )
           s.pop() ;    
        }
            cout<<endl;
      } 
     }
    } 

    1.3.2 邻接表表示的图的深度优先遍历

    思路一样,就是代码不一样

    1.3.2.1 递归

    void DFSX2(adjgraph *G,int x){//邻接表深度递归辅助算法 
        Edgenode *p;
        visited[x]=true;//标记为访问过 
        cout<<G->vexlist[x].dingdian<<" ";
        p=G->vexlist[x].firstedge;
        while(p){
         if(!visited[p->xiabiao])
           DFSX2(G,p->xiabiao);
           p=p->next ;
    }
    }
    void diguishen2(adjgraph *G){//邻接表深度递归算法 
        for(int i=0;i<G->n;i++){//将每个节点标记为未访问过 
            visited[i]=false;
        }
        int count=1;
        for(int i=0;i<G->n;i++){//遍历每一个节点 
           if(!visited[i]){
             cout<<"森林"<<count++<<":"; 
             DFSX2(G,i);
            cout<<endl;
         }  
       }
    }

    1.3.2.2 非递归

    void feidiguishen(adjgraph *G){//邻接表深度非递归算法 
        stack<int>s;
        Edgenode *p;
        for(int j=0;j<G->n;j++){//将每个节点标记为未访问过 
          visited[j]=false; }
          int count=1;//森林数目 
          for(int i=0;i<G->n;i++){//遍历每个节点 
             if(!visited[i]){
             cout<<"森林"<<count<<":"; 
             visited[i]=true;
             s.push(i);
             cout<<G->vexlist[i].dingdian<<" ";
             p=G->vexlist[i].firstedge;
             while(!s.empty()){
                p=G->vexlist[s.top()].firstedge ;
                bool flag = false;
                while(p){
                 if(!visited[p->xiabiao ]){
                     visited[p->xiabiao ]=true;
                     cout<<G->vexlist[p->xiabiao].dingdian<<" ";//输出该节点 
         		 s.push(p->xiabiao );  
        		 p=G->vexlist[p->xiabiao].firstedge ;
        		 flag = true;
         		break;
        }
        	else{
        		 p=p->next ;
       	 }
      	 }
       	if(flag == false){
        	 s.pop() ;
        }
      } 
      cout<<endl;
      count++;
      }
     } 
    } 

    1.4图的广度优先遍历

    广度优先遍历和我们之前将的二叉树的层序遍历几乎一样。有一个不同的地方就是图不一定是连通的,可能有几个森林,而二叉树一定是连通的。
    思路:借助队列来实现。

    1. 首先对每个顶点标记为未访问过。
    2. 然后遍历所有的顶点,对于顶点v,如果顶点v没有被访问过,则访问这个顶点,并且把这个顶点标记为访问过,并且把这个顶点压入队列中。
    3. 当队列不为空时,取队首顶点t,然后访问所有和顶点t邻接的顶点x。如果顶点x没有被访问过,则访问这个顶点,并且把这个顶点标记为访问过,把这个顶点x压入队列中。每一次访问顶点就从队首取出一个顶点即可。
    4. 当队列为空时,再去考察其他没有访问过的顶点。

    1.4.1 邻接矩阵表示的图的广度优先遍历

    void guangdu2(mygraph *G) {//邻接矩阵广度优先遍历 
        for(int j=0;j<G->n;j++){
           visited[j]=false;
       }
        queue<int>s;
        int count=1;
        for(int i=0;i<G->n;i++){
           if(!visited[i]){
           cout<<"森林"<<count++<<":"; 
           visited[i]=true;
           cout<<G->vertex[i]<<" ";
           s.push(G->vertex[i]);
        while(!s.empty() ){
            int k=s.front()  ;
            s.pop() ;
            for(int j=0;j<G->n;j++){
              if(G->edge [k][j]!=0){
                 if(!visited[j]){
                    visited[j]=true;
                   cout<<G->vertex[j]<<" ";
                   s.push(G->vertex[j]); 
            }      
           } 
          }
        }
       cout<<endl;
       }   
      }
    }

    1.4.2邻接表表示的图的广度优先遍历

    void guangdu(adjgraph *G){//邻接表广度优先遍历 
        for(int j=0;j<G->n;j++){
          visited[j]=false;
        }
        queue<int>s;
        Edgenode *p;
        int count=1;
        for(int i=0;i<G->n;i++){
          if(!visited[i]){
            cout<<"森林"<<count++<<":"; 
            visited[i]=true;
            cout<<G->vexlist[i].dingdian<<" ";
            s.push(G->vexlist[i].dingdian);
            while(!s.empty() ){
               p=G->vexlist[s.front()].firstedge;
               s.pop() ;
               while(p!=NULL){
                 if(!visited[p->xiabiao]){
                    visited[p->xiabiao]=true;
              	cout<<G->vexlist[p->xiabiao].dingdian<<" ";
          		 s.push(p->xiabiao); 
         		}
             p=p->next;    
          } 
         }
          cout<<endl;
       } 
      
      }
     }

    1.5主程序

    void zrh(){
          int x=0;//用来判断当前的无向图是用邻接矩阵还是邻接表来表示的,0代表邻接矩阵,1代表邻接表 
         cout<<"-----------------------------------------------------------------"<<endl;
         cout<<"0.退出                                                          |"<<endl;
        cout<<"1.通过从文件读入创建一个无向图的邻接矩阵                        |"<<endl;
        cout<<"2.通过从文件读入创建一个无向图的邻接表                          |"<<endl;
        cout<<"3.通过输入创建一个无向图的邻接矩阵                              |"<<endl;
        cout<<"4.通过输入创建一个无向图的邻接表                                |"<<endl;
        cout<<"5.显示邻接矩阵                                                  |"<<endl;
        cout<<"6.显示邻接表                                                    |"<<endl;
        cout<<"7.将邻接矩阵转化为邻接表并显示                                  |"<<endl;
        cout<<"8.将邻接表转化为邻接矩阵并显示                                  |"<<endl;
        cout<<"9.深度优先递归遍历无向图                                        |"<<endl;
        cout<<"10.深度优先非递归遍历无向图                                     |"<<endl;
        cout<<"11.广度优先遍历无向图                                           |"<<endl;
        cout<<"-----------------------------------------------------------------"<<endl; 
        mygraph g;//创建无向图 的邻接矩阵 
        adjgraph t;//创建无向图的邻接表 
        int n;
        cin>>n;
        while(n){
          switch(n){
            case 1:
              wenjianCreateGraph(&g);
              x=0;
             break;
           case 2:
            wenjianCreateadjGraph(&t);
            x=1;
            break;   
          case 3:
             CreateGraph(&g);
           x=0;
          break;  
         case 4:
            CreateadjGraph(&t);
            x=1;
            break;  
         case 5:
           shuchugraph(&g);
           x=0;
           break;  
         case 6:
           shuchuadjgraph(&t);
             x=1;
            break;  
        case 7:
           adjgraph t1;
           cout<<"邻接矩阵为:"<<endl; 
           shuchugraph(&g);
           cout<<"转化为邻接表后为:"<<endl ;
          jzhuanhuanb(&g,&t1);
         shuchuadjgraph(&t1);
         break;
        case 8:
          mygraph t2;
          cout<<"邻接表为:"<<endl; 
          shuchuadjgraph(&t);
          cout<<"转化为邻接矩阵后为:"<<endl ;
          bzhuanhuanj(&t2,&t);
          shuchugraph(&t2);
          break;
        case 9:
        if(x==1){ 
           diguishen2(&t);
       }   
        else{
           diguishen(&g);
        }     
           break;
         case 10:
           if(x==1){
            feidiguishen(&t); 
         }
          else{
             feidiguishen2(&g);
         } 
         break;
        case 11:
           if(x==0){
               guangdu2(&g);
          }
         else{
             guangdu(&t);
          } 
          break;
         default :
          n=0;
         break;                      
     }
     cout<<"-----------------------------------------------------------------"<<endl;
     cout<<"0.退出                                                          |"<<endl;
     cout<<"1.通过从文件读入创建一个无向图的邻接矩阵                        |"<<endl;
     cout<<"2.通过从文件读入创建一个无向图的邻接表                          |"<<endl;
     cout<<"3.通过输入创建一个无向图的邻接矩阵                              |"<<endl;
     cout<<"4.通过输入创建一个无向图的邻接表                                |"<<endl;
     cout<<"5.显示邻接矩阵                                                  |"<<endl;
     cout<<"6.显示邻接表                                                    |"<<endl;
     cout<<"7.将邻接矩阵转化为邻接表并显示                                  |"<<endl;
     cout<<"8.将邻接表转化为邻接矩阵并显示                                  |"<<endl;
     cout<<"9.深度优先递归遍历无向图                                        |"<<endl;
     cout<<"10.深度优先非递归遍历无向图                                     |"<<endl;
     cout<<"11.广度优先遍历无向图                                           |"<<endl;
     cout<<"-----------------------------------------------------------------"<<endl; 
     if(x==0)
      cout<<"当前无向图为邻接矩阵表示法,请根据提示选择正确的操作:"<<endl;
     else
       cout<<"当前无向图为邻接表表示法,请根据提示选择正确的操作:"<<endl;
     if(n!=0)
      cin>>n;
     } 
    }   

    1.6结果分析

    展开全文
  • 哈工大数据结构作业1 需要代码的直接加QQ:1755786931 ,备注作业1代码即可。或者csdn直接私聊我(回复很慢,不是很经常看csdn) 要求如下 话不多说,直接上测试样例 1.从文件读入表达式 2.保存表达式 3.显示表达式 ...

    哈工大数据结构作业1

    代码思路等待更新中。。。。

    哈工大数据结构实验二——哈夫曼编码与译码方法
    哈工大2019秋数据结构期末试题
    哈工大数据结构实验二——哈夫曼编码与译码方法
    哈工大数据结构实验一 线性结构及其应用

    要求如下

    在这里插入图片描述

    话不多说,直接上测试样例

    1.从文件读入表达式

    在这里插入图片描述

    2.保存表达式

    在这里插入图片描述

    3.显示表达式

    在这里插入图片描述

    4.中缀转后缀并显示栈的变化过程

    在这里插入图片描述

    5.计算后缀表达式的值并显示栈的变化过程

    在这里插入图片描述

    5.扩充到实数集合《数据用的是float类型》

    在这里插入图片描述

    6. 将结果输出到文件中

    在这里插入图片描述
    在这里插入图片描述

    代码如下

    在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述在这里插入图片描述在这里插入图片描述

    同一份代码不一样的截图,大家哪个看着顺眼就哪个来

    在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    展开全文
  • 哈尔滨工业大学数据结构试题
  • 哈工大2018年秋数据结构期末复习

    千次阅读 2020-06-02 21:39:29
    就是一篇很普通的数据结构的复习时的笔记而已 本文原载于我的博客,地址:https://blog.guoziyang.top/archives/19/
  • 哈工大数据结构

空空如也

空空如也

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

哈工大数据结构

数据结构 订阅