浅谈数据结构之图的数据结构实现（二）

最新推荐文章于 2024-04-18 14:03:09 发布
最新推荐文章于 2024-04-18 14:03:09 发布
阅读量353 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cuixhao110/article/details/103225069
版权

上一篇

浅谈数据结构之图的数据结构实现（二）

无向邻接矩阵

public class MatrixNDG {

    /**
     * 图顶点个数
     */
    int size;

    /**
     * 图顶点名称
     */
    char[] vertexs;

    /**
     * 图的关系矩阵
     */
    int[][] matrix;

    /**
     * 构造图
     * @param vertexs 图的所有顶点
     * @param edges 图的关系数组
     */
    public MatrixNDG(char[] vertexs, char[][] edges) {
        size = vertexs.length;
        matrix = new int[size][size];
        this.vertexs = vertexs;
        for (char[] c : edges) {
            // 根据顶点名称确定对应的矩阵下标
            int p1 = getPosition(c[0]);
            int p2 = getPosition(c[1]);
            // 无向图在对称位置存储
            matrix[p1][p2] = 1;
            matrix[p2][p1] = 1;
        }
    }

    private int getPosition(char ch) {
        for (int i = 0; i < vertexs.length; i++) {
            if (vertexs[i] == ch) {
                return i;
            }
        }
        return -1;
    }

    private void print() {
        System.out.print("  ");
        for (char c : vertexs) {
            System.out.print(c + " ");
        }
        System.out.println();
        int k = 0;
        for (int[] i : matrix) {
            System.out.print(vertexs[k++] + " ");
            for (int j : i) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'};
        char[][] edges = new char[][]{{'A', 'C'},
                {'A', 'D'},
                {'A', 'F'},
                {'B', 'C'},
                {'C', 'D'},
                {'E', 'G'},
                {'D', 'G'},
                {'I', 'J'},
                {'J', 'G'},
                {'E', 'H'},
                {'H', 'K'}};
        MatrixNDG pG = new MatrixNDG(vexs, edges);
        pG.print();
    }
}

输出图：
  A B C D E F G H I J K 
A 0 0 1 1 0 1 0 0 0 0 0 
B 0 0 1 0 0 0 0 0 0 0 0 
C 1 1 0 1 0 0 0 0 0 0 0 
D 1 0 1 0 0 0 1 0 0 0 0 
E 0 0 0 0 0 0 1 1 0 0 0 
F 1 0 0 0 0 0 0 0 0 0 0 
G 0 0 0 1 1 0 0 0 0 1 0 
H 0 0 0 0 1 0 0 0 0 0 1 
I 0 0 0 0 0 0 0 0 0 1 0 
J 0 0 0 0 0 0 1 0 1 0 0 
K 0 0 0 0 0 0 0 1 0 0 0

有向邻接矩阵

public class MatrixDG {

    /**
     * 图顶点个数
     */
    int size;

    /**
     * 图顶点名称
     */
    char[] vertexs;

    /**
     * 图的关系矩阵
     */
    int[][] matrix;

    /**
     * 构造图
     * @param vertexs 图的所有顶点
     * @param edges 图的关系数组
     */
    public MatrixDG(char[] vertexs, char[][] edges) {
        size = vertexs.length;
        matrix = new int[size][size];
        this.vertexs = vertexs;
        for (char[] c : edges) {
            // 根据顶点名称确定对应的矩阵下标
            int p1 = getPosition(c[0]);
            int p2 = getPosition(c[1]);
            // 无向图在对称位置存储
            matrix[p1][p2] = 1;
            // 这行代码打开就是无向邻接矩阵
            //matrix[p2][p1] = 1;
        }
    }

    private int getPosition(char ch) {
        for (int i = 0; i < vertexs.length; i++) {
            if (vertexs[i] == ch) {
                return i;
            }
        }
        return -1;
    }

    private void print() {
        System.out.print("  ");
        for (char c : vertexs) {
            System.out.print(c + " ");
        }
        System.out.println();
        int k = 0;
        for (int[] i : matrix) {
            System.out.print(vertexs[k++] + " ");
            for (int j : i) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'};
        char[][] edges = new char[][]{{'A', 'C'},
                {'A', 'D'},
                {'A', 'F'},
                {'B', 'C'},
                {'C', 'D'},
                {'E', 'G'},
                {'D', 'G'},
                {'I', 'J'},
                {'J', 'G'},
                {'E', 'H'},
                {'H', 'K'}};
        MatrixDG pG = new MatrixDG(vexs, edges);
        pG.print();
    }
}

输出图
  A B C D E F G H I J K 
A 0 0 1 1 0 1 0 0 0 0 0 
B 0 0 1 0 0 0 0 0 0 0 0 
C 0 0 0 1 0 0 0 0 0 0 0 
D 0 0 0 0 0 0 1 0 0 0 0 
E 0 0 0 0 0 0 1 1 0 0 0 
F 0 0 0 0 0 0 0 0 0 0 0 
G 0 0 0 0 0 0 0 0 0 0 0 
H 0 0 0 0 0 0 0 0 0 0 1 
I 0 0 0 0 0 0 0 0 0 1 0 
J 0 0 0 0 0 0 1 0 0 0 0 
K 0 0 0 0 0 0 0 0 0 0 0

无向邻接表

public class ListNDG {

    /**
     * 邻接表节点类， 单链表数据结构
     */
    Vertex[] vertesLists;

    /**
     * 链表大小
     */
    int size;

    class Vertex {
        char ch;
        Vertex next;

        Vertex (char ch) {
            this.ch = ch;
        }
        void add(char ch) {
            Vertex node = this;
            while (node.next != null) {
                node = node.next;
            }
            node.next = new Vertex(ch);
        }
    }

    public ListNDG(char[] vertexs, char[][] edges) {
        size = vertexs.length;
        //确定邻接表大小
        this.vertesLists = new Vertex[size];
        //设置邻接表每一个信息
        for (int i = 0; i < size; i++) {
            this.vertesLists[i] = new Vertex(vertexs[i]);
        }
        //存储信息
        for (char[] c : edges) {
            int p1 = getPosition(c[0]);
            vertesLists[p1].add(c[1]);
            int p2 = getPosition(c[1]);
            vertesLists[p2].add(c[0]);
        }
    }

    private int getPosition(char c) {
        for (int i = 0; i < size; i++) {
            if (vertesLists[i].ch == c) {
                return i;
            }
        }
        return -1;
    }

    public void print() {
        for (int i = 0; i < size; i++) {
            Vertex temp = vertesLists[i];
            while (temp != null) {
                System.out.print(temp.ch + " ");
                temp = temp.next;
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'};
        char[][] edges = new char[][]{{'A', 'C'},
                {'A', 'D'},
                {'A', 'F'},
                {'B', 'C'},
                {'C', 'D'},
                {'E', 'G'},
                {'D', 'G'},
                {'I', 'J'},
                {'J', 'G'},
                {'E', 'H'},
                {'H', 'K'}};
        ListNDG pG = new ListNDG(vexs, edges);
        pG.print();
    }
}

输出：
A C D F 
B C 
C A B D 
D A C G 
E G H 
F A 
G E D J 
H E K 
I J 
J I G 
K H

有向邻接表

public class ListDG {

    /**
     * 邻接表节点类， 单链表数据结构
     */
    Vertex[] vertesLists;

    /**
     * 链表大小
     */
    int size;

    class Vertex {
        char ch;
        Vertex next;

        Vertex (char ch) {
            this.ch = ch;
        }
        void add(char ch) {
            Vertex node = this;
            while (node.next != null) {
                node = node.next;
            }
            node.next = new Vertex(ch);
        }
    }

    public ListDG(char[] vertexs, char[][] edges) {
        size = vertexs.length;
        //确定邻接表大小
        this.vertesLists = new Vertex[size];
        //设置邻接表每一个信息
        for (int i = 0; i < size; i++) {
            this.vertesLists[i] = new Vertex(vertexs[i]);
        }
        //存储信息
        for (char[] c : edges) {
            int p1 = getPosition(c[0]);
            vertesLists[p1].add(c[1]);
            // 此处打开就是无相邻接表
            //int p2 = getPosition(c[1]);
            //vertesLists[p2].add(c[0]);
        }
    }

    private int getPosition(char c) {
        for (int i = 0; i < size; i++) {
            if (vertesLists[i].ch == c) {
                return i;
            }
        }
        return -1;
    }

    public void print() {
        for (int i = 0; i < size; i++) {
            Vertex temp = vertesLists[i];
            while (temp != null) {
                System.out.print(temp.ch + " ");
                temp = temp.next;
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'};
        char[][] edges = new char[][]{{'A', 'C'},
                {'A', 'D'},
                {'A', 'F'},
                {'B', 'C'},
                {'C', 'D'},
                {'E', 'G'},
                {'D', 'G'},
                {'I', 'J'},
                {'J', 'G'},
                {'E', 'H'},
                {'H', 'K'}};
        ListDG pG = new ListDG(vexs, edges);
        pG.print();
    }
}


输出：
A C D F 
B C 
C D 
D G 
E G H 
F 
G 
H K 
I J 
J G 
K
24K不怕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机数据结构学术论文
12-22
是一位资深的计算机教授写的 特别适合一些想在数据结构方面深入学习的有很大的帮助
图像基本处理算法的简单实现（二）
暗黑世界
12-09 751
原文地址链接 4）膨胀腐蚀          属于什么心态学==，膨胀、腐蚀、击中/击不中变换、细化…（又晕了T^T）。简单点好像就是集合运算，图像与一结构元素的交差补什么的。图像一点的周围是否符合结构元素，然后该怎么处理。            结构元素（B）由0和1组成，用于扫描比较二值化图像（A）。   膨胀：          1、用结构元素B，扫描图像A的每一个
浅谈数据结构以及其特点
Aliven888的博客
07-30 1286
文档声明： 以下资料均属于本人在学习过程中产出的学习笔记，如果错误或者遗漏之处，请多多指正。并且该文档在后期会随着学习的深入不断补充完善。 资料仅供学习交流使用。 作者：Aliven888 1、简介： 这边文章将会从数据结构的定义、逻辑结构、存储结构、数据运算、相互关系、算法的时间复杂度等几个方面对数据结构进行介绍。 2、什么是数据结构 在了解数据结构之前，我们先了解下什么是数据、数据元素、数据项以及数据对象 什么是数据？ 数据实际上可以简单理解为我们对客观事物的符号表示；在计算机科学中，随着我们.
浅谈数据结构与算法
韩的博客
08-05 690
浅谈数据结构与算法 为什么要学习数据结构与算法数据结构与算法相关概念数据结构的两个层次数据结构的运算总结： ) 为什么要学习数据结构与算法   很多同学对数据结构与算法的第一印象，可能是觉得它复杂、深奥、难以理解。   另外，同学们可能还有一个疑问：在平时的开发工作中，一个产品，从开发到上线，似乎都不会用到数据结构与算法，也就是说即使不懂数据结构与算法，也能出色地完成日常的工作任务，照样能拿到高薪。那我们为什么还要学习数据结构与算法呢？   其实，一个很重要的原因是为了应对面试，数据结构与算法，是很多名企面
【浅谈数据结构】栈的基本函数与操作
GuLeng______的博客
01-24 2777
文章目录栈1.栈的定义2.栈的实现方式2.1线性栈 vs 链表栈 的优缺点2. 顺序栈栈（线性栈）2.1子函数含义 以及 实现1. 线性栈的结构类型2. InitStack3. StackEmpty4. StackFull5. Push6. StackPop7. StackTop8. StackDestroy2、顺序栈的基本操作 栈 栈是一种特殊的线性表，它们的逻辑结构和线性表相同，但是运算规则相比线性表有更多的限制，故又称它们为 运算受限 的线性表。 1.栈的定义 栈（Stack）是只能在一段（栈
浅谈数据结构---红黑树、二叉树
最新发布
xiaohua616的博客
04-18 575
浅谈数据结构---红黑树、二叉树
浅谈Java中常用数据结构的实现类Collection和M
10-31
浅谈Java中常用数据结构的实现类Collection和Map共7页.pdf.zip
浅谈《数据结构》的重要性.pdf
08-07
#资源达人分享计划#
浅谈iOS 数据结构之链表
08-29
主要介绍了浅谈iOS 数据结构之链表，本文详细的介绍了单链表和双链表，具有一定的参考价值，有兴趣的可以了解一下
浅谈数据结构课程教学内容的联系.pdf
08-07
#资源达人分享计划#
浅谈数据结构之栈和队列及基础算法和面试真题（一）
cuixhao110的博客
07-20 2303
浅谈数据结构之栈和队列
浅谈数据结构之图的深度优先和广度优先遍历算法（三）
cuixhao110的博客
12-05 580
浅谈数据结构之图的深度优先和广度优先遍历算法（三） 上一篇
浅谈数据结构之图的面试真题-Dijkstra最短路径算法（四）
cuixhao110的博客
12-06 563
浅谈数据结构之图的面试真题-Dijkstra最短路径算法（四） 上一篇 算法描述 通过Dijkstra计算图G中的最短路径时，需要指定起点vs(即从顶点vs开始计算)。 此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点，而U则是记录还未求出最短路径的顶点(以及该顶点到起点vs的距离)。 操作步骤 初始时，S只包含起点vs；U包含除vs外的其他顶点，且U中顶点的距离为"起点vs到该顶点...
浅谈数据结构之图（一）
cuixhao110的博客
11-24 473
浅谈数据结构之图（一） 基本概念 1. 图的定义 图(graph)是由一些点(vertex)和这些点之间的连线(edge)所组成的；其中，点通常被成为"顶点(vertex)"，而点与点之间的连线则被成为"边或弧"(edege)。通常记为，G=(V,E)。 2. 图的种类 根据边是否有方向，将图可以划分为：无向图和有向图。 3. 邻接点和度 3.1 邻接点 一条边上的两个顶点叫做邻接点。 例如，...
浅谈数据结构之树（一）
cuixhao110的博客
07-25 429
浅谈数据结构之树
浅谈数据结构之线性表（一）
cuixhao110的博客
06-11 350
数据结构之线性表基本概念数组和链表单链表、双链表、循环链表 基本概念 线性表是一种逻辑结构，相同数据类型的n个数据元素的有限序列，除第一个元素外，每个元素有且仅有一个直接前驱，除最后一个元素外，每个元素有且仅有一个直接后继。 线性表具有以下特点： 元素个数有限 逻辑上元素有先后次序 数据类型相同 仅讨论元素间的逻辑关系 数组和链表 单链表、双链表、循环链表 ...
浅谈数据结构之线性表基础算法和面试真题（二）
cuixhao110的博客
06-11 345
上一篇 线性表基础算法线性表反转算法线性表取中间节点，开阔算法思路。 线性表反转算法 算法描述：线性表反转，就是由原来的前一个节点指向后一个节点，变成后一个节点指向前一个节点，例如1，2，3，4的顺序，反转成4，3，2，1。 /** * 反转链表 * 时间复杂度O(n),空间复杂度O(1) * @param head * @return */ public static Li...
浅谈数据结构之树的基础算法（二）
cuixhao110的博客
07-26 340
浅谈数据结构之树（二） 上一篇
浅谈算法和数据结构: 十 平衡查找树之B树
06-10
B树是一种平衡查找树，其特点是能够在相对较短的时间内完成查找、插入和删除操作，因此在文件系统和数据库系统中被广泛应用。 B树的定义如下： 1.每个节点最多有m个子节点； 2.除根节点和叶子节点外，其他节点至少...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值