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

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

教材学习内容总结

图是跟一般的树的概念所区分，它不约束除根节点外的每一个顶点有且只能有一个父节点。图中没有根，每个顶点都能与最多n-1个其它节点相连。
- 邻接：两个顶点之间有一条边，则称这两个顶点是邻接的
- 路径：连接两个顶点之间的一系列边称为两个顶点间的路径，边的条数称为路径长度
- 环路：首顶点与末顶点相同且路径中没有边重复的路径
- 点的入度：以点为终点的有向边数
- 点的出度：以点为起点的有向边数
图可以根据是否具有方向分为两种：有向图和无向图
- 无向图：在图中若任意两个顶点的边为无向边，则称该图为无向图
- 有向图：在图中所有边为有向边，便是有向图
- 有序通常用尖括号表示，无序通常用圆括号表示
图也可以根据每条边是否带有权重分为加权图和网络，可以根据边或弧的多少分为稠密图和稀疏图，生成树是一种特殊的图
生成树：包含无向图所有顶点的极小联通子图
图的表示：
- 邻接表：邻接表，存储方法跟树的孩子链表示法相类似，是一种顺序分配和链式分配相结合的存储结构。如这个表头结点所对应的顶点存在相邻顶点，则把相邻顶点依次存放于表头结点所指向的单向链表中

邻接矩阵：邻接矩阵：利用一个二维数组实现的矩阵，行列的元素代表顶点，而矩阵中的元素代表边

十字链表：十字链表（Orthogonal List)是有向图的另一种链式存储结构。该结构可以看成是将有向图的邻接表和逆邻接表结合起来得到的
图的遍历：
- 广度优先遍历：像石头落在水里激起的涟漪一样，一层一层的遍历
- BFS算法之所以叫做广度优先搜索，是因为它始终将已发现的顶点和未发现的之间的边界，沿其广度方向向外扩展。亦即，算法首先会发现和s距离为k的所有顶点，然后才会发现和s距离为k+1的其他顶点。同深度优先搜索相反，BFS宽度优先搜索每次选择深度最浅的节点优先扩展。并且当问题有解时，宽度优先算法一定能够找到解，并且在单位耗散时间的情况下，可以保证找到最优解。
- 深度优先遍历：深度优先遍历，顾名思义即为一条道走到黑的搜索策略，行不通退回来换另外一条道再走到黑，依次直到搜索完成。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。可以通过图示清晰的说明。假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。
图的最小生成树：个有n个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有n个结点，并且有保持图连通的权值和边最小

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

问题1：如何简要理解拓扑算法
问题1解决方案：：类似于二叉树的层次遍历，遍历所有结点，将入度为0的结点存在一个栈中，依次输出栈内的各个结点时，将每个节点的子节点的度减1，然后将其中度为0的结点存入栈中，循环执行上述操作，直到所有结点遍历完。
问题2：如何理解和绘制十字链表
问题2解决方案：首先明确一些概念
- 入弧和出弧：入弧表示图中发出箭头的顶点，出弧表示箭头指向的顶点
- 弧头和弧尾：弧尾表示图中发出箭头的顶点，弧头表示箭头指向的顶点
- 同弧头和同弧尾：同弧头，弧头相同弧尾不同；同弧尾，弧头不同互为相同
  具体绘制过程：
- 第一步，列出图的所有顶点，并进行编号。每行含三个方格的横格，顶点那栏分别填写各顶点，入弧和出弧的暂时不管
- 第二步，画出各行对应的顶点表示出弧的所有关系。画的时候为了方便之后的连线，建议可以将弧尾相同的画在同一行，将弧头相同的画同一列。填写弧尾与弧头，同弧头和同弧尾先暂时不管。
- 第三步，连线。将表示顶点的三格图中入弧指向对应列所有的四格方格。四格方格中，同弧头指向本列，同弧尾指向本行。若出弧或同弧尾右边没有方格，则为空。
问题3：DFS和BFS算法比较，各自有什么特点和应用场景
问题3解决方案：
- DFS深度优先搜索，空间需求较低，不需要BFS需要一个队列保存搜索过程中搜索记录；其次，深搜在搜索过程中要考虑回溯，在搜索HTML链接，爬取数据方面适用颇多；多用于解决连通性问题。
- BFS广度优先搜索，空间需求较高，根据其搜索模式，因为是按层进行搜索，所以很容易求得最短路径。可以应用于Dijkstral和prim算法

代码调试中的问题和解决过程

问题1：如何用Java具体实现深度遍历
问题1解决方案：具体实现如下。只要建立邻接矩阵和对应的标志数组，就可以相对容易的实现。DFS利用递归来实现比较易懂，DFS非递归就是将需要的递归的元素利用一个栈Stack来实现，以达到递归时候的顺序。

import java.util.Stack;

public class Graph {
//节点个数
    private static int number = 8;
//创立访问标志数组的布尔型数组
    private boolean[] flag;

//创立要遍历节点的数组
    private int[] num= {1,2,3,4,5,6,7,8};
//创立这几个数字的邻接矩阵
    private int[][] edges = {
            {0, 1, 1, 0, 0, 0, 0, 0},
            {1, 0, 0, 1, 1, 0, 0, 0},
            {1, 0, 0, 0, 0, 1, 1, 0},
            {0, 1, 0, 0, 0, 0, 0, 1},
            {0, 1, 0, 0, 0, 0, 0, 1},
            {0, 0, 1, 0, 0, 0, 1, 0},
            {0, 0, 1, 0, 0, 1, 0, 0},
            {0, 0, 0, 1, 1, 0, 0, 0},

    };

    void DFSTraverse() {
        //设置一个和数字个数同等大小的布尔数组
        flag = new boolean[number] ;
        //从顶点开始，实现深度遍历
        for (int i = 0; i < number; i++) {
            if (flag[i] == false) {
                // 如果当前顶点没有被访问，进入DFS
                DFS(i);
            }
        }
    }
//完成一次遍历，直到后面无连接节点
    void DFS(int i) {
        // 标记第num[i]个节点被访问
        flag[i] = true;
        //将该节点打印
        System.out.print(num[i] + " ");
        //寻找与num[i]节点相连的下一个访问节点
        for (int j = 0; j < number; j++) {
            //从标志数组第0位开始顺序查找，如果这一点未被访问，且与第num[i]个节点相连
            if (flag[j] == false && edges[i][j] == 1) {
                //递归
                DFS(j);
            }
        }
    }

    void DFS_Map(){
        flag = new boolean[number];
        Stack<Integer> stack =new Stack<Integer>();
        for(int i=0;i<number;i++){
            if(flag[i]==false){
                flag[i]=true;
                System.out.print(num[i]+" ");
                stack.push(i);
            }
            while(!stack.isEmpty()){
                int k = stack.pop();
                for(int j=0;j<number;j++){
                    if(edges[k][j]==1&&flag[j]==false){
                        flag[j]=true;
                        System.out.print(num[j]+" ");
                        stack.push(j);
                        break;
                    }
                }

            }
        }
    }


//测试类
    public static void main(String[] args) {

        Graph graph = new Graph();
        System.out.println("DFS递归:");
        graph.DFSTraverse();
        System.out.println();

        System.out.println("DFS非递归:");
        graph.DFS_Map();

    }
}

问题2： kruskal(克鲁斯卡尔)算法的实现思路是什么，应该如何具体实现
问题2解决方案：
- 现将所有边进行权值的从小到大排序
- 定义一个一维数组代表连接过的边，数组的下标为边的起点，值为边的终点
- 按照排好序的集合用边对顶点进行依次连接，连接的边则存放到一维数组中
- 用一维数组判断是否对已经连接的边能构成回路，有回路则无效，没回路则是一条有效边
- 重复3，4直至遍历完所有的边为止，即找到最小生成树

public class GraphKruskal {
//定义Edge型数组
    private Edge[] edges;
    private int edgeSize;

    public GraphKruskal(int edgeSize) {
        //参数个数
        this.edgeSize = edgeSize;
        edges = new Edge[edgeSize];
        createEdgeKruskal();

    }
    //创建边的集合，从小到大
    private void createEdgeKruskal() {

        Edge edge0 = new Edge(1, 3, 1);
        Edge edge1 = new Edge(4, 6, 2);
        Edge edge2 = new Edge(2, 5, 3);
        Edge edge3 = new Edge(3, 6, 4);
        Edge edge4 = new Edge(2, 3, 5);
        Edge edge5 = new Edge(3, 4, 5);
        Edge edge6 = new Edge(1, 4, 5);
        Edge edge7 = new Edge(3, 5, 6);
        Edge edge8 = new Edge(1, 2, 6);
        Edge edge9 = new Edge(5, 6, 6);

        edges[0] = edge0;
        edges[1] = edge1;
        edges[2] = edge2;
        edges[3] = edge3;
        edges[4] = edge4;
        edges[5] = edge5;
        edges[6] = edge6;
        edges[7] = edge7;
        edges[8] = edge8;
        edges[9] = edge9;
    }

    //kruskal算法创建最小生成树
    public void createMinSpanTreeKruskal() {

        // 定义一个一维数组，下标为连线的起点，值为连线的终点
        int[] parent = new int[edgeSize];
        for (int i = 0; i < edgeSize; i++) {
            parent[i] = 0;
        }
        int sum = 0;
        //将数组中每一个元素都赋给左边
        for (Edge edge : edges) {
            // 找到起点和终点在临时连线数组中的最后连接点,核心
            int start = find(parent, edge.start);
            int end = find(parent, edge.end);
            // 通过起点和终点找到的最后连接点是否为同一个点，是则产生回环

            if (start != end) {
                // 没有产生回环则将临时数组中，起点为下标，终点为值
                parent[start] = end;
                System.out.println("访问到了节点：{" + start + "," + end + "}，权值：" + edge.weight);
                sum += edge.weight;
            }

        }

        System.out.println("最小生成树的权值总和：" + sum);

    }

    // 获取集合的最后节点
    private int find(int parent[], int index) {
        while (parent[index] > 0) {
            index = parent[index];
        }
        return index;
    }

    //连接顶点的边
    class Edge {
        private int start;
        private int end;
        private int weight;

        public Edge(int start, int end, int weight) {
            this.start = start;
            this.end = end;
            this.weight = weight;

        }

    }


    public static void main(String[] args) {
        GraphKruskal graphKruskal = new GraphKruskal(10);
        graphKruskal.createMinSpanTreeKruskal();
    }

}

问题3：Dijkstra的作用是什么，如何具体实现Dijkstra算法
问题3解决方案：迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。
- 具体实现思路详见代码

public class Dijkstra {
    public static final int M = 10000; // 代表正无穷

    public static void main(String[] args) {
        // 二维数组每一行分别是 A、B、C、D、E 各点到其余点的距离,
        // A -> A 距离为0, 常量M 为正无穷
        int[][] weight1 = {
                   {0, 13, 8, M, 30, M, 32},
                   {M, 0,  M,  M, M, 9, 7 },
                   {M, M, 0,  5,  M, M , M},
                   {M, M, M, 0,  6,  M , M},
                   {M, M, M, M,  0,  2 , M},
                   {M, M, M, M,  M,  0 ,17},
                   {M, M, M, M,  M,  M , 0},

        };

        int start = 0;

        int[] shortPath = dijkstra(weight1, start);

        for (int i = 0; i < shortPath.length; i++)
            System.out.println("从" + start + "出发到" + i + "的最短距离为：" + shortPath[i]);
    }

    public static int[] dijkstra(int[][] weight, int start) {
        // 接受一个有向图的权重矩阵，和一个起点编号start（从0编号，顶点存在数组中）
        // 返回一个int[] 数组，表示从start到它的最短路径长度
        int n = weight.length; // 顶点个数
        int[] shortPath = new int[n]; // 保存start到其他各点的最短路径
        String[] path = new String[n]; // 保存start到其他各点最短路径的字符串表示
        for (int i = 0; i < n; i++)
            path[i] = new String(start + "-->" + i);
        int[] visited = new int[n]; // 标记当前该顶点的最短路径是否已经求出,1表示已求出

        // 初始化，第一个顶点已经求出
        shortPath[start] = 0;
        visited[start] = 1;

        for (int count = 1; count < n; count++) { // 要加入n-1个顶点
            int k = -1; // 选出一个距离初始顶点start最近的未标记顶点
            int dmin = Integer.MAX_VALUE;
            for (int i = 0; i < n; i++) {
                if (visited[i] == 0 && weight[start][i] < dmin) {
                    dmin = weight[start][i];
                    k = i;
                }
            }

            // 将新选出的顶点标记为已求出最短路径，且到start的最短路径就是dmin
            shortPath[k] = dmin;
            visited[k] = 1;

            // 以k为中间点，修正从start到未访问各点的距离
            for (int i = 0; i < n; i++) {
                //如果 '起始点到当前点距离' + '当前点到某点距离' < '起始点到某点距离', 则更新
                if (visited[i] == 0 && weight[start][k] + weight[k][i] < weight[start][i]) {
                    weight[start][i] = weight[start][k] + weight[k][i];
                    path[i] = path[k] + "-->" + i;
                }
            }
        }
        for (int i = 0; i < n; i++) {

            System.out.println("从" + start + "出发到" + i + "的最短路径为：" + path[i]);
        }
        System.out.println("=====================================");
        return shortPath;
    }
}

代码托管

（

）

上周考试错题总结

结对及互评

评分标准

正确使用Markdown语法（加1分）：
- 不使用Markdown不加分
- 有语法错误的不加分（链接打不开，表格不对，列表不正确...）
- 排版混乱的不加分
模板中的要素齐全（加1分）
- 缺少“教材学习中的问题和解决过程”的不加分
- 缺少“代码调试中的问题和解决过程”的不加分
- 代码托管不能打开的不加分
- 缺少“结对及互评”的不能打开的不加分
- 缺少“上周考试错题总结”的不能加分
- 缺少“进度条”的不能加分
- 缺少“参考资料”的不能加分
教材学习中的问题和解决过程, 一个问题加1分
代码调试中的问题和解决过程, 一个问题加1分
本周有效代码超过300分行的（加2分）
- 一周提交次数少于20次的不加分
其他加分：
- 周五前发博客的加1分
- 感想，体会不假大空的加1分
- 排版精美的加一分
- 进度条中记录学习时间与改进情况的加1分
- 有动手写新代码的加1分
- 课后选择题有验证的加1分
- 代码Commit Message规范的加1分
- 错题学习深入的加1分
- 点评认真，能指出博客和代码中的问题的加1分
- 结对学习情况真实可信的加1分
扣分：
- 有抄袭的扣至0分
- 代码作弊的扣至0分
- 迟交作业的扣至0分

点评模板：

博客中值得学习的或问题：
- 讲解内容较为丰富
代码中值得学习的或问题：
- 结合所学，给出了算法的具体实现
基于评分标准，我给本博客打分：18分
参考示例

点评过的同学博客和代码

本周结对学习情况
- 20182302
- 结对学习内容
  - 深度优先遍历的具体实现
  - 十字链表的绘制
  - 辨析图和数的区别
上周博客互评情况
- 20182302

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

数据结构学习也算到尾声了，图这一章算法比较丰富，需要我们花费时间逐一认真理解，并落实到代码实现。只有这样，我们对数据结构的理解才能真正融会贯通

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	200/200	2/2	20/20
第二周	300/500	2/4	18/38
第三周	500/1000	3/7	22/60
第四周	300/1300	2/9	30/90
第五周	1600/2900	2/11	20/110
第六周	981 /3881	2/12	25/135
第七周	1700/5518	3/15	45/180
第八周	700/6200	2/17	20/200
第九周	4300/10500	2/19	30/230
第十周	2064/12564	1/20	30/260

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

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

计划学习时间:30小时
实际学习时间:30小时
改进情况：

(有空多看看现代软件工程课件
软件工程师能力自我评价表)

参考资料

posted @ 2019-11-24 19:05 20182304张子正阅读(344) 评论(0) 编辑收藏举报

刷新页面返回顶部

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

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

教材学习内容总结

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

代码调试中的问题和解决过程

代码托管

上周考试错题总结

结对及互评

评分标准

点评模板：

点评过的同学博客和代码

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

学习进度条

参考资料

公告