数据结构之图

最新推荐文章于 2024-08-09 16:47:28 发布
最新推荐文章于 2024-08-09 16:47:28 发布
阅读量94 收藏
点赞数
文章标签： 数据结构 队列 java 算法 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangshuo2020/article/details/116655512
版权

一、基本知识
在这里插入图片描述
二、快速入门
①创建
在这里插入图片描述

package com.ws.数据结构.图.创建;

import java.util.ArrayList;
import java.util.Arrays;

public class Grapn {

    private ArrayList<String> dingTextList;//存储顶点集合

    private int[][] edges;//存储图对应的邻接矩阵

    private int numBian;//边的数目

    public static void main(String[] args) {
        //测试图创建
        int n=5;//节点的个数
        String v1[] = {"A","B","C","D","E"};
        //创建图
        Grapn grapn = new Grapn(n);
        //循环添加顶点
        for (String a:v1){
            grapn.insertDing(a);
        }
        //添加边
        grapn.insertBian(0,1,1);//A-B
        grapn.insertBian(0,2,1);
        grapn.insertBian(1,2,1);
        grapn.insertBian(1,3,1);
        grapn.insertBian(1,4,1);
        //显示临界就诊
        grapn.printfTu();
    }

    //构造器
    public Grapn(int n){
        //初始化矩阵和顶点集合
        edges=new int[n][n];//初始化邻接矩阵

        dingTextList=new ArrayList<>(n);//初始化顶点集合

        numBian=0;//初始化边个数
    }

    //插入节点
    public void insertDing(String ding){
        dingTextList.add(ding);
    }

    /**
     * 添加边
     * @param v1  节点下标
     * @param v2  节点下标
     * @param bian  边（二维数组值 1连）
     */
    public void insertBian(int v1,int v2,int bian){
        edges[v1][v2]=bian;
        edges[v2][v1]=bian;
        numBian++;//边数目增加
    }

    //图中常用的额方法
    //返回节点的个数
    public int getNumVer(){
        return dingTextList.size();
    }
    //返回边的个数
    public int getNumBian(){
        return numBian;
    }
    //返回节点i对应的数据
    public String getValueByIndex(int i){
        return dingTextList.get(i);
    }
    //返回v1和v2的权值
    public int getBian(int v1,int v2){
        return edges[v1][v2];
    }
    //显示图
    public void printfTu(){
        for (int[] link:edges){
            System.out.println(Arrays.toString(link));
        }
    }
}
[0, 1, 1, 0, 0]
[1, 0, 1, 1, 1]
[1, 1, 0, 0, 0]
[0, 1, 0, 0, 0]
[0, 1, 0, 0, 0]

②深度优先遍历
在这里插入图片描述

package com.ws.数据结构.图.遍历.深度优先DFS;

import java.util.ArrayList;
import java.util.Arrays;

public class Grapn {

    private ArrayList<String> dingTextList;//存储顶点集合

    private int[][] edges;//存储图对应的邻接矩阵

    private int numBian;//边的数目
    //定义数组，标记某个节点是否被访问过
    private boolean[] ifFangWen;

    public static void main(String[] args) {
        //测试图创建
        int n=5;//节点的个数
        String v1[] = {"A","B","C","D","E"};
        //创建图
        Grapn grapn = new Grapn(n);
        //循环添加顶点
        for (String a:v1){
            grapn.insertDing(a);
        }
        //添加边
        grapn.insertBian(0,1,1);//A-B
        grapn.insertBian(0,2,1);
        grapn.insertBian(1,2,1);
        grapn.insertBian(1,3,1);
        grapn.insertBian(1,4,1);
        //显示临界就诊
        grapn.printfTu();

        //深度遍历测试
        System.out.println("深度优先遍历");
        grapn.DFS();
    }

    //构造器
    public Grapn(int n){
        //初始化矩阵和顶点集合
        edges=new int[n][n];//初始化邻接矩阵

        dingTextList=new ArrayList<>(n);//初始化顶点集合

        numBian=0;//初始化边个数

        ifFangWen=new boolean[n];//记录某个节点是否被访问
    }

    //插入节点
    public void insertDing(String ding){
        dingTextList.add(ding);
    }

    /**
     * 添加边
     * @param v1  节点下标
     * @param v2  节点下标
     * @param bian  边（二维数组值 1连）
     */
    public void insertBian(int v1,int v2,int bian){
        edges[v1][v2]=bian;
        edges[v2][v1]=bian;
        numBian++;//边数目增加
    }

    //图中常用的额方法
    //返回节点的个数
    public int getNumVer(){
        return dingTextList.size();
    }
    //返回边的个数
    public int getNumBian(){
        return numBian;
    }
    //返回节点i对应的数据
    public String getValueByIndex(int i){
        return dingTextList.get(i);
    }
    //返回v1和v2的权值
    public int getBian(int v1,int v2){
        return edges[v1][v2];
    }
    //显示图
    public void printfTu(){
        for (int[] link:edges){
            System.out.println(Arrays.toString(link));
        }
    }


    /**
     * 得到第一个临接节点的下标  开头
     * @param index  当前节点的下标
     * @return   如果存在就返回对应下标 y
     */
    public int getLinBiao(int index){
        for (int i=0;i<dingTextList.size();i++){
            if (edges[index][i]>0) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取下一个临接节点
     * @param x  前一个临接节点的x坐标
     * @param y               y
     * @return  下一个邻接节点的y坐标
     */
    public int getNextBiao(int x,int y){
        for (int j=y+1;j<dingTextList.size();j++){
            if(edges[x][j]>0){
                return j;
            }
        }
        return -1;
    }


    /**
     * 深度优先遍历
     * @param ifFangWen  是否访问过标志
     * @param i   第一次是0  路径节点
     */
    private void DFS(boolean[] ifFangWen,int i){
        //输出访问过的节点
        System.out.print(getValueByIndex(i)+"->");//返回相应节点的数据
        //将该节点设置为已经访问
        ifFangWen[i]=true;
        //查找i的邻接节点
        int linjie=getLinBiao(i);// A   b   c  ...
        //递归找邻接节点
        while (linjie!=-1){
            if (!ifFangWen[i]){
                //没有被访问过，就递归找访问过的 输出路径
                DFS(ifFangWen,i);
            }
            //节点已经被访问过就查找
            linjie=getNextBiao(i,linjie);//  A-B  A-C
        }
    }

    /**
     * 重载，对多个起点（多个行）进行路径查找
     */
    public void DFS(){
        //遍历所有行（节点）
        for (int i=0;i<getNumBian();i++){
            if (!ifFangWen[i]){
                DFS(ifFangWen,i);
            }
        }
    }
}
[0, 1, 1, 0, 0]
[1, 0, 1, 1, 1]
[1, 1, 0, 0, 0]
[0, 1, 0, 0, 0]
[0, 1, 0, 0, 0]
深度优先遍历
A->B->C->D->E->

③广度优先遍历
在这里插入图片描述

package com.ws.数据结构.图.遍历.广度优先;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class Grapn {

    private ArrayList<String> dingTextList;//存储顶点集合

    private int[][] edges;//存储图对应的邻接矩阵

    private int numBian;//边的数目
    //定义数组，标记某个节点是否被访问过
    private boolean[] ifFangWen;

    public static void main(String[] args) {
        //测试图创建
        int n=5;//节点的个数
        String v1[] = {"A","B","C","D","E"};
        //创建图
        Grapn grapn = new Grapn(n);
        //循环添加顶点
        for (String a:v1){
            grapn.insertDing(a);
        }
        //添加边
        grapn.insertBian(0,1,1);//A-B
        grapn.insertBian(0,2,1);
        grapn.insertBian(1,2,1);
        grapn.insertBian(1,3,1);
        grapn.insertBian(1,4,1);
        //显示临界就诊
        grapn.printfTu();

        //深度遍历测试
        //System.out.println("深度优先遍历");
        //grapn.DFS();

        //广度优先遍历
        System.out.println();
        System.out.println("广度优先遍历");
        grapn.guangDFS();
    }

    //构造器
    public Grapn(int n){
        //初始化矩阵和顶点集合
        edges=new int[n][n];//初始化邻接矩阵

        dingTextList=new ArrayList<>(n);//初始化顶点集合

        numBian=0;//初始化边个数

        ifFangWen=new boolean[n];//记录某个节点是否被访问
    }

    //插入节点
    public void insertDing(String ding){
        dingTextList.add(ding);
    }

    /**
     * 添加边
     * @param v1  节点下标
     * @param v2  节点下标
     * @param bian  边（二维数组值 1连）
     */
    public void insertBian(int v1,int v2,int bian){
        edges[v1][v2]=bian;
        edges[v2][v1]=bian;
        numBian++;//边数目增加
    }

    //图中常用的额方法
    //返回节点的个数
    public int getNumVer(){
        return dingTextList.size();
    }
    //返回边的个数
    public int getNumBian(){
        return numBian;
    }
    //返回节点i对应的数据
    public String getValueByIndex(int i){
        return dingTextList.get(i);
    }
    //返回v1和v2的权值
    public int getBian(int v1,int v2){
        return edges[v1][v2];
    }
    //显示图
    public void printfTu(){
        for (int[] link:edges){
            System.out.println(Arrays.toString(link));
        }
    }


    /**
     * 得到第一个临接节点的下标  开头
     * @param index  当前节点的下标
     * @return   如果存在就返回对应下标 y
     */
    public int getLinBiao(int index){
        for (int i=0;i<dingTextList.size();i++){
            if (edges[index][i]>0) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取下一个临接节点
     * @param x  前一个临接节点的x坐标
     * @param y               y
     * @return  下一个邻接节点的y坐标
     */
    public int getNextBiao(int x,int y){
        for (int j=y+1;j<dingTextList.size();j++){
            if(edges[x][j]>0){
                return j;
            }
        }
        return -1;
    }


    /**
     * 深度优先遍历
     * @param ifFangWen  是否访问过标志
     * @param i   第一次是0  路径节点
     */
    private void DFS(boolean[] ifFangWen,int i){
        //输出访问过的节点
        System.out.print(getValueByIndex(i)+"->");//返回相应节点的数据
        //将该节点设置为已经访问
        ifFangWen[i]=true;
        //查找i的邻接节点
        int linjie=getLinBiao(i);// B  A
        //递归找邻接节点
        while (linjie!=-1){
            if (!ifFangWen[i]){
                //没有被访问过，就递归找访问过的 输出路径
                DFS(ifFangWen,i);
            }
            //节点已经被访问过就查找
            linjie=getNextBiao(i,linjie);//  A-B  A-C
        }
    }

    /**
     * 重载，对多个起点（多个行）进行路径查找
     */
    public void DFS(){
        //遍历所有行（节点）
        for (int i=0;i<getNumBian();i++){
            if (!ifFangWen[i]){
                DFS(ifFangWen,i);
            }
        }
    }

    //广度优先遍历
    private void guangDFS(boolean[] ifFangWen,int i){
        int u;//队列头节点下标  节点
        int lin;//临接节点的下标
        //队列  广度遍历节点访问顺序记录
        LinkedList<Integer> queue = new LinkedList<>();
        //访问节点
        System.out.print(getValueByIndex(i)+"->");
        //标记成已访问
        ifFangWen[i]=true;
        //将节点加入序列
        queue.addLast(i);
        while (!queue.isEmpty()){
            //取出队列的头节点下标
            u=queue.removeFirst();
            //得到第一个临接节点得到下标
            lin=getLinBiao(u);
            while (lin!=-1){
                //找到
                //是否访问过
                if (!ifFangWen[lin]){
                    //输出
                    System.out.print(getValueByIndex(lin)+"->");
                    //标记已经访问
                    ifFangWen[lin]=true;
                    //入队
                    queue.addLast(lin);
                }
                //访问过 还以当前节点，继续访问
                lin=getNextBiao(u,lin);
            }
        }
    }

    //广度优先遍历  所有的节点
    public void guangDFS(){
        for (int i=0;i<getNumBian();i++){
            if (!ifFangWen[i]){
                guangDFS(ifFangWen,i);
            }
        }
    }
}

[0, 1, 1, 0, 0]
[1, 0, 1, 1, 1]
[1, 1, 0, 0, 0]
[0, 1, 0, 0, 0]
[0, 1, 0, 0, 0]

广度优先遍历
A->B->C->D->E->
wangshuo（24考研上岸版）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-图-遍历输出-c++
lu__ren的博客
12-08 660
图的深度优先遍历和广度优先遍历 c++ 第一部分是用邻接表创建的图，具体注释可参见我的第一篇文章 // typedef struct ArcNode { int adjvex; int info; struct ArcNode *next; } ArcNode; typedef struct VNode { int data; struct ArcNode *firstarc; } VNode,AdjList[maxnum]; typedef struct {
数据结构：图的实现（输出有向图的邻接矩阵与出度和最大的点）
banxia_hnu_zjw的博客
11-21 3230
数据结构：图的实现（输出有向图的邻接矩阵与出度和最大的点） 【问题描述】 需要分别基于邻接矩阵和邻接表来实现图ADT 需要实现图的各个基本操作 小明最近在学习数据结构中图的相关知识，他需要输出有向图的邻接矩阵并找出有向图中出度最大的点。你能帮他解决这个问题么？ 【输入形式】 每一组第一行有两个数n、m表示n个顶点，m条有向边。 输入顶点信息，并用空格隔开，顶点信息以大写字母表示 接下来有m行...
数据结构-无向图
kongduxue的专栏
08-05 3万+
1.图的定义         图（Graph）是由顶点(vertex)的有穷非空集合和顶点之间边(edge)的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合 a.若顶点之间 Vi 和 Vj 之间没有方向,则为无向边,用无序偶对( Vi , Vj )表示 b.若顶点之间 Vi 和 Vj 之间有方向,则为有向边(也称弧),用有序偶对&lt; Vi ,...
第12周项目3图深度优先遍历算法实现
liuyi6666的博客
11-16 455
问题及代码： /* * * * * *烟台大学计算机与控制工程学院 *作者：刘熠 *时间：2015年11月16日 * * * * *问题描述：操作用邻接表存储的图 * */ #ifndef GRAPH_H_INCLUDED #define GRAPH_H_INCLUDED #define MAXV 100
数据结构——图
厚积而薄发，谋定而后动
06-30 2万+
提示：以下内容不适合零基础人员，仅供笔者复习之用。 一、图的定义         图是由顶点的有穷非空集合和顶点之间边的集合组成， 通常表示为: G（V，E）， 其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 线性结构中，元素仅有线性关系，每个元素只有一个直接前驱和直接后继；树形结构中，数据元素（结点）之间有着明显的层次关系，每层上的元素可能和下一层中多个元素
数据结构之图的邻接矩阵建立
05-08
数据结构之图的邻接矩阵建立
数据结构1800试题.pdf
05-02
- **有向图**和**字符串**：非线性数据结构，有向图用于表示对象之间的定向关系，字符串是字符序列，常见于文本处理。 通过这份试题集，学习者可以深入理解数据结构的各个方面，巩固理论知识，提升编程技能，尤其...
数据结构教案
12-13
数据结构教案 数据结构是计算机科学中的一门重要课程，它研究的是计算机中数据的存储、组织和管理方式。数据结构的基本概念包括数据元素、数据结构、数据类型、抽象数据类型等。 数据元素是数据结构中讨论的基本...
数据结构学习数据结构学习
02-12
常见的数据结构有数组、链表、栈、队列、树、图等。 数组是最基本的数据结构，它是一组相同类型的数据元素的有序集合，通过索引访问。数组的优点是访问速度快，但插入和删除操作效率较低，因为可能需要移动大量元素...
Python数据结构之图的应用示例
01-20
本文实例讲述了Python数据结构之图的应用。分享给大家供大家参考，具体如下： 一、图的结构 二、代码 # -*- coding:utf-8 -*- #! python3 def searchGraph(graph,start,end): results =[] generatePath(graph,...
图解程序员画流程图、数据结构图及各种复杂图形的Graphviz工具入门
热门推荐
Jason Gel 的专栏
05-03 3万+
画linux内核文件系统结构图、内存分配以及学习数据结构树、图时，发现使用Graphviz非常的方便快捷。鉴于网上关于它的安装、使用不是特别具体，本博文将一步步告诉大家如何快速地使用Graphviz画相关的流程图、树形图等。告诉大家Graphviz的快速入门。
数据结构--------图结构的存储与输出__全世界最可爱的王小帅_CSDN博客
ggaycat的博客
11-22 1429
数据结构cpp版——图结构的存储与输出 图的存储主要分为顺序存储和链式存储 顺序存储的方式主要是邻接矩阵，而链式存储的结构有多种这里主要介绍链式邻接表。 邻接矩阵表示法： 1，建立一个一维数组用来存储图的所有顶点（即建立一个顶点表），建立一个二维数组用来表示各个顶点间是否有边（即建立一个邻接矩阵） 2，假设图A=（V,E）有n个顶点，则图的邻接矩阵是个二维数组A.Edge[n][n] 无向图的邻接矩阵表示法 设i,j∈V 若A.Edge[i][j]=1,则(i,j)∈E，即i j之间存在边，若.Edge[i
高阶数据结构——B树
weixin_74310945的博客
08-08 1214
B树：有序数组+平衡多叉树；B+树：有序数组链表+平衡多叉树；B*树：一棵更丰满的，空间利用率更高的B+树。单论树的高度，查找效率来看B树系列确实不错，但是也存在一些缺点。1.空间利用率低，占用的空间大。2.插入和删除数据时，需要进行分裂，涉及到数据的挪动，效率低。3.虽然比起红黑树等，高度更低，但是在内存中都是一个量级的，搜索效率并不比红黑树快多少（在内存中没什么优势）
数据结构之Map和Set（下）
最新发布
我要学编程的博客
08-09 1199
冲突-解决-闭散列、开散列/哈希桶 手动实现哈希表 哈希表和Java类的关系 有关Map和Set的相关练习：只出现一次的数字、随机链表的复制、宝石与石头、前k个高频单词
树和二叉树
2401_83720143的博客
08-08 521
2、如果对一颗有n个结点的完全二叉树（深度为 | log以2为底n的对数 | +1 ）的结点。1、在二叉树的第i层上至多有2的 i-1次方个结点（i>=1），至少有i个结点。1、具有n个结点的完全二叉树的深度为 ： | log以2为底n的对数 | +1。2、深度为k的二叉树至多有2的k次方减1个结点（k>=1），至少有k个结点。2、如果2i>n,则结点i为叶子结点，无左孩子，否则其左孩子是结点 2i。3、如果2i+1>n，则结点 i无右孩子，否则其右孩子是结点 2i+1。根结点：非空树中无前驱结点的结点。
常见8种数据结构
qq_43575301的博客
08-08 2199
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
【数据结构】顺序结构实现：特殊完全二叉树（堆）+堆排序
2203_76003626的博客
08-07 1476
堆+堆排序
工程数据计算机处理：图形数据结构详解
常见的图形数据结构包括线性表、数组、栈、队列、链表、树和图等。这些结构满足一些基本要求，如便于描述和操作图形，占用较少的存储空间，以及方便检索。 线性表是一种基本的数据结构，由有序的数据元素组成，所有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值