标签：可变   有用   返回   ++i   字符串   防止   入队   意义   教材   

20182301 2019-2020-1 《数据结构与面向对象程序设计》第十周学习总结

教材学习内容总结

图的结构构成

• 顶点（vertex）：图中的数据元素，如图一

• 边（edge）：图中连接这些顶点的线，如图一
  

• G=（V,E） 或者 G=（V（G），E（G））
  • 其中 V（G）表示图结构所有顶点的集合，顶点可以用不同的数字或者字母来表示。E（G）是图结构中所有边的集合，每条边由所连接的两个顶点来表示。

  • 图结构中顶点集合V（G）不能为空，必须包含一个顶点，而图结构边集合可以为空，表示没有边。

    图的基本概念

• 无向图

• 如果一个图结构中，所有的边都没有方向性，那么这种图便称为无向图。典型的无向图，如图二所示。由于无向图中的边没有方向性，这样我们在表示边的时候对两个顶点的顺序没有要求。例如顶点VI和顶点V5之间的边，可以表示为(V2， V6),也可以表示为(V6，V2)。
  

• 有向图

• 一个图结构中，边是有方向性的，那么这种图就称为有向图，如图三所示。由于图的边有方向性，我们在表示边的时候对两个顶点的顺序就有要求。我们采用尖括号表示有向边，例如<V2，V6>表示从顶点V2到顶点V6，而<V6，V2>表示顶点V6到顶点V2。
  

• 顶点的度
• 连接顶点的边的数量称为该顶点的度。顶点的度在有向图和无向图中具有不同的表示。对于无向图，一个顶点V的度比较简单，其是连接该顶点的边的数量，记为D(V)。
• 对于有向图要稍复杂些，根据连接顶点V的边的方向性，一个顶点的度有入度和出度之分。
  • 入度是以该顶点为端点的入边数量， 记为ID(V)。
  • 出度是以该顶点为端点的出边数量， 记为OD(V)。
• 邻接矩阵
• 邻接顶点是指图结构中一条边的两个顶点。邻接顶点在有向图和无向图中具有不同的表示。对于无向图，邻接顶点比较简单。
• 对于有向图要稍复杂些，根据连接顶点V的边的方向性，两个顶点分别称为起始顶点(起点或始点)和结束顶点(终点)。有向图的邻接顶点分为两类：
  • 入边邻接顶点：连接该顶点的边中的起始顶点。例如，对于组成<V2，V6>这条边的两个顶点，V2是V6的入边邻接顶点。
  • 出边邻接顶点：连接该顶点的边中的结束顶点。例如，对于组成<V2，V6>这条边的两个顶点，V6是V2的出边邻接顶点。
• 无向完全图

• 如果在一个无向图中， 每两个顶点之间都存在条边，那么这种图结构称为无向完全图。典型的无向完全图，如图四所示。
  

• 理论上可以证明，对于一个包含M个顶点的无向完全图，其总边数为M(M-1)/2。比如图四总边数就是5（5-1）/ 2 = 10。
• 有向完全图

• 如果在一个有向图中，每两个顶点之间都存在方向相反的两条边，那么这种图结构称为有向完全图。典型的有向完全图，如图五所示。
  

• 理论上可以证明，对于一个包含N的顶点的有向完全图，其总的边数为N(N-1)。这是无向完全图的两倍，这个也很好理解，因为每两个顶点之间需要两条边。
• 有向无环图（DAG图）
• 如果一个有向图无法从某个顶点出发经过若干条边回到该点，则这个图是一个有向无环图。
• 有向无环图可以利用在区块链技术中。
• 无权图和有权图

• 这里的权可以理解成一个数值，就是说节点与节点之间这个边是否有一个数值与它对应，对于无权图来说这个边不需要具体的值。对于有权图节点与节点之间的关系可能需要某个值来表示，比如这个数值能代表两个顶点间的距离，或者从一个顶点到另一个顶点的时间，所以这时候这个边的值就是代表着两个节点之间的关系，这种图被称为有权图；
  

• 图的连通性

• 图的每个节点不一定每个节点都会被边连接起来，所以这就涉及到图的连通性，如下图：
  

• 可以发现上面这个图不是完全连通的。
• 简单图 ( Simple Graph)
• 对于节点与节点之间存在两种边，这两种边相对比较特殊
  • 自环边（self-loop）：节点自身的边，自己指向自己。
  • 平行边（parallel-edges）：两个节点之间存在多个边相连接。
    

• 这两种边都是有意义的，比如从A城市到B城市可能不仅仅有一条路，比如有三条路，这样平行边就可以用到这种情况。不过这两种边在算法设计上会加大实现的难度。而简单图就是不考虑这两种边。

常见图的算法

• 广度优先遍历
  • 遍历方法：从一个顶点开始，辐射状地优先遍历其周围较广的区域
  • 实现方法：需要一个队列来保存遍历过的定点顺序，以便按出队的顺序再去访问这些顶点的邻接顶点
  • 顶部伪代码：
    • 访问初始结点v并标记结点v为已访问。
    • 结点v入队列
    • 当队列非空时，继续执行，否则算法结束。
    • 出队列，取得队头结点u。
    • 查找结点u的第一个邻接结点w。
    • 若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
      1. 若结点w尚未被访问，则访问结点w并标记为已访问。
      2. 结点w入队列
      3. 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。
  • 图片解释：其广度优先算法的遍历顺序为：1->2->3->4->5->6->7->8
    
• 深度优先遍历
  • 遍历方法：从一个顶点开始，沿边去探寻每一个顶点。（通俗一点：一条道走到黑！）
  • 实现方法：通过栈来保存遍历过的定点顺序，遇到一个顶点，只是先获得它，并不出栈（因为要多次利用它），然后把它的第一个未被访问的节点入队列。如果没有相邻的未被访问的顶点，才把这个顶点出栈。
  • 顶部伪代码：
    • 访问初始结点v，并标记结点v为已访问。
    • 查找结点v的第一个邻接结点w。
    • 若w存在，则继续执行4，否则算法结束。
    • 若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。
    • 查找结点v的w邻接结点的下一个邻接结点，转到步骤3。
  • 图片解释：其深度优先遍历顺序为1->2->4->8->5->3->6->7
    

最短路径问题

• 无权图的单源最短路径

• 首先，我们将起点的路径长设为0，其他顶点路径长设为负数（也可以是其他不可能的值，图例中用？表示），下例以v1作为起点
  

• 接着我们将起点所指向的顶点的路径长设为1，可以肯定的是，只有被路径长为0的起点所指向的顶点的路径长为1，本例中即v3和v4：
  

• 接下来，我们将路径长为1的顶点（v3和v4）所指向的顶点的路径长设为2，同样可以肯定，只有被路径长为1的顶点所指向的顶点的路径长为2。不过此时会遇到一个问题：v3是v4所指向的顶点，但v3的路径长显然不应该被设为2。所以我们需要对已知路径长的顶点设一个“已知”标记，已知的顶点不再更改其路径长，具体做法在给出代码时将写明。本例中，路径长要被设为2的顶点是v2、v5、v6
  

• 规律是：将路径长为i的顶点所指向的未知顶点的路径长设为i+1，i从0开始，结束条件即：当前路径长为i的顶点没有指向其它顶点，或所指向的顶点均为已知。
• 需要注意的是结束条件的说法，我们并没有要求所有顶点都变为已知，因为确定某顶点为起点后，是有可能存在某个顶点无法由起点出发然后到达的，比如我们的例子中的v0，不存在从v1到v0的路径。

• 将最短路径的计算结果存于一个线性表中，其结构如下：
  

• 其中“一行”为线性表中的一个元素，每一行的四个单元格就是一个元素中的四个域：顶点、是否已知、与起点最短路径长、最短路径中自身的前一个顶点。
  
  

• 那么之前计算最短路径的过程用这个表来表示的话，就是下面这样：
  
• 简单伪代码

//无权最短路径计算，图存于邻接表graph，结果存入pathTable，起点即start
void unweightedPath(Node* graph,struct pathNode* pathTable,size_t  start)
{
    pathTable[start].known=true;
    pathTable[start].distance=0; //若pathTable[x].distance为0，则其preV是无用的，我们不予理睬

    //初始化pathTable中的其他元素

    //curDis即当前距离，我们要做的是令distance==curDis的顶点所指的未知顶点的distance=curDis+1
    for(int curDis=0;curDis<numVertex;++curDis)
    {
        for(int i=0;i<numVertex;++i)
        {
            if(!pathTable[i].known&&pathTable[i].distance==curDis)
            {
                pathTable[i].known=true;
                //遍历pathTable[i]所指向的顶点X
                {
                    if(!pathTable[X].known)
                    {
                        pathTable[X].preV=i;
                        pathTable[X].distance=curDis+1;
                    }
                }
            }
        }
    }
}

• 令已知顶点所指未知顶点的distance=curDis+weight

• 解决的思路是：我们罗列出所有已知顶点指向的所有未知顶点，看这些未知顶点中谁的distance被修改后会是最小的，最小的那个我们就修改其distance，并认为它已知。
  

• 首先是正常的初始化（我们将边的权重也标识出来），假设起点为v0：
  

• 接着我们罗列出所有已知顶点（只有v0）指向的所有未知顶点：v1、v2、v3。然后发现若修改它们的distance，则v1.distance=v0.distance+1=1，v2.distance=v0.distance+3=3，v3.distance=v0.distance+5=5。显然v1被修改后的distance是未知顶点中最小的，所以我们只修改v1的distance，并将v1设为已知，v2、v3不动：
  

• 接着我们继续罗列出所有已知顶点（v0、v1）指向的所有未知顶点：v2、v3、v4。然后发现若修改它们的distance，则v2.distance=v0.distance+3=3，v4.distance=v1.distance+1=2，v3.distance=v1.distance+1=2（虽然v0也指向v3，但是通过v0到v3的路径长大于从v1到v3，所以v3的distance取其小者），其中v3和v4的新distance并列最小，我们任选其一比如v4，然后只修改v4的distance，并将v4设为已知，其它不动：
  

• 继续，我们罗列出所有已知顶点（v0、v1、v4）指向的所有未知顶点：v2、v3、v6，发现若修改，则v2.distance=3，v3.distance=2，v6.distance=3，所以我们只修改v3的distance，并将v3设为已知：
  

• 继续，我们罗列出所有已知顶点（v0、v1、v3、v4）指向的所有未知顶点：v2、v5、v6，发现若修改，则v2.distance=3，v5.distance=10，v6.distance=3，我们在v2和v6中任选一个如v2，只修改v2.distance，并将v2设为已知：
  

• 继续，我们罗列出所有已知顶点指向的所有未知顶点：v5、v6，发现若修改，则v5.distance=5，v6.distance=3，所以我们只修改v6：
  

• 最后，罗列出的未知顶点只有v5，若修改，其distance=5，我们将其修改并设为已知，算法结束：
  

• 有权图伪代码：

//有权最短路径计算，图存于邻接表graph，结果存入pathTable，起点即start
void weightedPath(Node* graph,struct pathNode* pathTable,size_t  start)
{
    //初始化pathNode数组
    
    size_t curV;
    while(true)
    {
        //找到可确定distance的未知顶点中新distance最小的那个，存入curV，若没有则跳出循环
        //令pathNode[curV].distance和pathNode[curV].prev修改为正确的值
        pathNode[curV].known=true;
    }
}

教材学习中的问题和解决过程

• 问题1：了解拓扑排序

• 问题1解决方案：（详见链接5）
  

• 拓扑排序就是对图中顶点进行的排序，其要求是：若存在从vx到vy的路径，那么排序结果中vx必须在vy之前。
• 进行拓扑排序的图必须是有向无圈图。
  • 在无向图中，若存在边（vx，vy）则必存在边（vy，vx），那么依拓扑排序的要求，vx就必须在vy的前面，同时vy又必须在vx前面，这显然是矛盾的，所以拓扑排序只能用于有向图。
  • 在有向有圈图中，比如上图，其中的圈v0-v1-v4-v3-v0就暗含着两条子路径：v0-v1-v4和v4-v3-v0，依前一条路径而言，排序结果中v0必须在v4前面，而依后一条路径而言，v4又必须在v0前面，这显然也是矛盾的，所以拓扑排序只能用于有向无圈图。
• 有向无圈图的两个特点：
  • 若图有向无圈，则必然存在一个入度为0的顶点。
  • 若图有向无圈，则去掉其入度为0的顶点及相连边（必为以该顶点为起点的有向边）后，图依然是有向无圈图。

• 伪代码：

void topSort(graph* g,size_t numVertex,size_t topResult)
{
    //两个表示顶点的变量，后面用
    size_t tempV,adjV;
    //存储各顶点入度的数组，顶点x的入度为indegree[x]
    size_t indegree[numVertex];
    伪：根据图g初始化indegree数组

    for(int i=0;i<numVertex;++i)
    {
        伪：从indegree中找到一个入度为0的顶点，存入tempV
        if(伪：没找到入度为0的顶点)
            伪：报错、返回
        
        topResult[i]=tempV;

        伪：通过g[tempV]遍历tempV为起点的边的终点，存入adjV
            indegree[adjV]--;
    }
}

• 问题2：图的广度优先遍历和深度优先遍历最根本的区别是什么？
• 问题2解决方案：
• 深度优先遍历的非递归做法时采用栈；广度优先遍历的非递归做法时采用队列
• 深度优先遍历是把每个分支深入到不能深入为止。具体的有先序遍历、中序遍历、后序遍历；广度优先遍历又称层序遍历，从上往下一层一层遍历
• 问题3：关于深度优先遍历的网络爬虫，深入了解一下
• 问题3解决方案：
• 网络爬虫（又被称为网页蜘蛛，网络机器人，在FOAF社区中间，更经常的称为网页追逐者），是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本。另外一些不常使用的名字还有蚂蚁、自动索引、模拟程序或者蠕虫。
• 访问频率限制；
  • Header头部信息校验；
  • 采用动态页面生成；
  • 采用动态页面生成；
  • 登录限制；
  • 验证码限制等。
• 爬虫实例

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class Reptile {
    
    public static void main(String[] args) {
        // 传入你所要爬取的页面地址
        String url1 = "http://www.xxxx.com.cn/";
        // 创建输入流用于读取流
        InputStream is = null;
        // 包装流, 加快读取速度
        BufferedReader br = null;
        // 用来保存读取页面的数据.
        StringBuffer html = new StringBuffer();
        // 创建临时字符串用于保存每一次读的一行数据，然后 html 调用 append 方法写入 temp;
        String temp = "";
        try {
            // 获取 URL;
            URL url2 = new URL(url1);
            // 打开流，准备开始读取数据;
            is = url2.openStream();
            // 将流包装成字符流，调用 br.readLine() 可以提高读取效率，每次读取一行;
            br = new BufferedReader(new InputStreamReader(is));
            // 读取数据, 调用 br.readLine() 方法每次读取一行数据, 并赋值给 temp, 如果没数据则值 ==null,
            // 跳出循环;
            while ((temp = br.readLine()) != null) {
                // 将 temp 的值追加给 html, 这里注意的时 String 跟 StringBuffer
                // 的区别前者不是可变的后者是可变的;
                html.append(temp);
            }
            // 接下来是关闭流, 防止资源的浪费;
            if (is != null) {
                is.close();
                is = null;
            }
            // 通过 Jsoup 解析页面, 生成一个 document 对象;
            Document doc = Jsoup.parse(html.toString());
            // 通过 class 的名字得到（即 XX）, 一个数组对象 Elements 里面有我们想要的数据, 至于这个 div的值，打开浏览器按下 F12 就知道了;
            Elements elements = doc.getElementsByClass("xx");
            for (Element element : elements) {
                // 打印出每一个节点的信息; 选择性的保留想要的数据, 一般都是获取个固定的索引;
                System.out.println(element.text());
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码学习中的问题和解决过程

• 问题1：计算出度和入度时，0总是多出很多，为什么？
• 问题1解决方案：
• 因为该并未初始化，所以没有的点都默认为0，于是

        for(i=0;i<5;i++){
            for(j=0;j<5;j++){
                a[i]=0;
                b[i]=0;
                dig[i][j]=-1;
            }
        }

• 问题2：输入点不能溢出，如下图：
  

• 问题2解决方案：

for(i=0;i<5;i++){
            System.out.println("请输入第一个： ");
            int input0 = scan.nextInt();
            dig[i][j] = input0;
            for(j=1;;j++){
            System.out.println("请问是否有下一个接点 ");
                String kong = scan.nextLine();
                char yn = scan.next().charAt(0);
                if(('Y' == yn)||(yn == 'y')){
                    String kong2 = scan.nextLine();
                    int input = scan.nextInt();
                    dig[i][j] = input;
                    a[i]++;
                }
                else{
                    j=0;
                    break;
                }

            }
        }
        for(int k=0;k<5;k++) {
            for(j=0;j<5;j++){
                for(i=0;dig[j][i]!=-1;i++){
                    if(dig[j][i]==k)
                        b[k]++;
                }
            }
        }

总代码

代码托管第十九章

书本代码第十九章

（statistics.sh脚本的运行结果截图）

上周考试错题总结

最近无检测，故无错题

点评过的同学博客和代码

• 本周结对学习情况
  • 20182326
  • 结对照片

- 结对学习内容
    - 学习图的定义
    - 学习图的遍历

• 上周博客互评情况
  • 20182326

其他（感悟、思考等，可选）

团队是重要，合作起来我们可以攻克所有难关。

学习进度条

尝试一下记录「计划学习时间」和「实际学习时间」，到期末看看能不能改进自己的计划能力。这个工作学习中很重要，也很有用。
耗时估计的公式：Y=X+X/N ，Y=X-X/N，训练次数多了，X、Y就接近了。

参考：软件工程软件的估计为什么这么难，软件工程 估计方法

• 计划学习时间:30小时

• 实际学习时间:45小时

• 改进情况：
  这周没有太多别的事情，专心学习Java，攻读数据结构。

参考资料

• 【数据结构】数据结构-图的基本概念
• 图的遍历（深度优先，广度优先）总结-java版
• 深度与广度的区别
• 图的理解
• 拓扑排序

20182301 2019-2020-1 《数据结构与面向对象程序设计》第十周学习总结

标签：可变   有用   返回   ++i   字符串   防止   入队   意义   教材   

原文地址：https://www.cnblogs.com/zhaopeining/p/11931443.html