1.4 构建空间网络图

最新推荐文章于 2024-05-21 18:34:36 发布
最新推荐文章于 2024-05-21 18:34:36 发布
阅读量1k 收藏 4
点赞数 1
分类专栏： 社区挖掘 文章标签： 图 空间网络 java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37665301/article/details/106610899
版权

1.4 构建空间网络图

目的

      我们将使用1.3节中获得的brightkite_nodes_available.txt文件和brightkite_edges_available.txt文件来构建空间网络图结构。brightkite_nodes_available.txt文件保存的是点的信息，每行表示一个点；brightkite_edges_available.txt文件保存的是边的信息，每行表示一条边。
      构建空间网络是为了将文本数据映射成程序可处理的图结构，使用图结构来存储空间图数据能提高处理效率。

存储结构

      图的存储结构一般可分为三种
      第一种是 用点集数组和边集数组存储一个图
      第二种是 用邻接矩阵存储一个图
      第三种是 用邻接链表存储一个图
      我们采用第三种存储方式，原因是邻接链表结构删除操作效率高，在之后的社区挖掘算法中存在大量删除操作。
      下面给出了一个图以及它对应的邻接链表存储结构。
图：
graph
邻接链表存储结构：
在这里插入图片描述

构建过程

数据结构

      在邻接链表表示图的存储结构中，众多节点构成了一个链表，众多链表构成了一个图。所以要先从节点类的设计开始。
点类
代码：

/**
 * 空间网络节点类
 * 每个节点由三个属性：id 、 位置 、度
 * @author dxt
 *
 */
public class Node {
	protected Node next;	//指向下一个顶点
	protected int id;	//唯一确定空间中的一个节点
	protected double x;	//位置 x--纬度
	protected double y;	//位置y--经度
	protected int degree;	//度：邻接点的个数
	protected int index; //用于搜索的索引
	protected int curDegree;	//当前的度
	
	//构造方法
	public Node(){}
	public Node(int id){
		super();
		this.id = id;
	}
	public Node(int id, double x, double y){
		super();
		this.id = id;
		this.x = x;
		this.y = y;
	}
	public Node(int id, double x, double y, int degree){
		super();
		this.id = id;
		this.x = x;
		this.y = y;
		this.degree = degree;
	}
	public Node(Node next, int id, double x, double y, int degree){
		super();
		this.next = next;
		this.id = id;
		this.x = x;
		this.y = y;
		this.degree = degree;
	}
	public Node(int id, double x, double y, int degree, int index){
		super();
		this.id = id;
		this.x = x;
		this.y = y;
		this.degree = degree;
		this.index = index;
	}
	
	//javabean
	public void setId(int id){
		this.id = id;
	}
	public int getId(){
		return this.id;
	}
	public void setX(double x){
		this.x = x;
	}
	public double getX(){
		return this.x;
	}
	public void setY(double y){
		this.y = y;
	}
	public double getY(){
		return this.y;
	}
	public void setDegree(int degree){
		this.degree = degree;
	}
	public int getDegree(){
		return this.degree;
	}
	public void setNext(Node next){
		this.next = next;
	}
	public Node getNext(){
		return this.next;
	}
	public void setIndex(int index){
		this.index = index;
	}
	public int getIndex(){
		return this.index;
	}
	
	public void setCurDegree(int d){
		this.curDegree = d;
	}
	public int getCurDegree(){
		return this.curDegree;
	}
	public void incCurDegree(){
		this.curDegree++;
	}
	
	/**
	 * 判断两个节点是否相同，
	 * 如果两个节点的id相同，则返回true; 否则返回false
	 * @param n
	 * @return
	 */
	public boolean equals(Node n){
		if(this.id == n.getId()){
			return true;
		}else{
			return false;
		}
	}
	/**
	 * 以欧式距离公式计算以获得相似性
	 * 没有多少参考价值，因为位置坐标是以经纬度标识的，以经纬度计算欧氏距离，所得的结果可用来比较大小，但没有实际意义
	 * @param n
	 * @return
	 */
	public double getSimilarity(Node n){
		double len = 0;
		double d_x = Math.abs((this.x - n.x));
		double d_y = Math.abs((this.y - n.y));
		len = Math.sqrt((d_x*d_x + d_y*d_y));
		len = Math.round(len * 1000) / 1000.0;//保留三位小数，精确到米  
		return len;
	}
	
	/**
	 * 计算两点间的距离
	 * 因为数据是基于位置的
	 * 可以依据经纬度计算出两点间的距离
	 * @return
	 */
	public double computeSim(Node n){
		double earth_radius = 6378.137;	//将地球看作圆，地球的平均半径,单位km
		double lat1 = this.x;	//获取位置1的纬度，北纬为正，南纬为负
		double lon1 = this.y;	//获取位置1的经度，东经为正，西经为负
		double lat2 = n.x;	//获取位置2的纬度
		double lon2 = n.y;	//获取位置2的经度
		
		double radLon1 = lon1 * (float)(Math.PI /180.0);	//转换为弧度
		double radLon2 = lon2 * (float)(Math.PI /180.0);
		double a = radLon1 - radLon2;
		double radLat1 = lat1 * (float)(Math.PI /180.0);	//转换为弧度
		double radLat2 = lat2 * (float)(Math.PI /180.0);
		double b = radLat1 - radLat2;
		double dis =  2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2)+  
                Math.cos(radLon1) * Math.cos(radLon2)* Math.pow(Math.sin(b / 2), 2)));  
		dis = dis * earth_radius;
		dis = Math.round(dis * 1000) / 1000.0;//保留三位小数，精确到米  
		return dis;
	}
}

解释：
      一个点具有众多属性。如果两个点的id相同，则认为它们是同一个点。给出了两种计算两点距离的方法，一种是欧式距离，一种是实际距离，两者的优缺点自己判断。
      当初写代码时人傻了，没有封装好，获取属性的方式也不统一。
链表类
代码：

/**
 * 一条链表
 * @author dxt
 *
 */
public class NodeLinkedList {
	private Node head;
	private int size;
	
	//构造方法
	public NodeLinkedList(){
		super();
		this.head = null;
		this.size = 0;
	}
	public NodeLinkedList(Node n){
		super();
		this.head = n;
		this.size = 1;
	}
	
	//获取链表元素个数
	public int getSize(){
		return this.size;
	}
	//获取链表头
	public Node getHead(){
		return this.head;
	}
	//获取头结点
	public Node getHeadNode(){
		int id = this.head.getId();
		double x = this.head.getX();
		double y = this.head.getY();
		int degree = this.head.getDegree();
		int index = this.head.getIndex();
		
		Node temp_node = new Node(id, x, y, degree, index);
		temp_node.setNext(null);	//指向空
		return temp_node;
	}
	
	//判断链表是否为空
	public boolean isEmpty(){
		if(this.size == 0){
			return true;
		}else{
			return false;
		}
	}
	
	/**
	 * 向链表头部添加节点n
	 * @param n
	 */
	public void addFirst(Node n){
		n.setNext(head);	//将n的下一个节点设为现有的头结点
		this.head = n;		//将n设为新的头节点
		this.size++;		//修改链表长度
	}
	/**
	 * 向链表中index位置添加元素
	 * @param n
	 * @param index
	 */
	public void add(Node n, int index){
		if(index < 0 || index > size){
			throw new IllegalArgumentException("Index is error");
		}
		
		//1.如果是向链表头部添加节点
		if(index == 0){
			this.addFirst(n);
		}else{
			//2.向非头部添加节点
			Node preNode = this.head;
			//2.1找到要插入节点的前一个节点
			for(int i=0; i<index-1; i++){
				preNode = preNode.next;
			}
			//2.2 进行插入操作
			n.setNext(preNode.next);	//要插入的节点n的下一个节点指向preNode节点的下一个节点
			preNode.next = n;			//preNode的下一个节点指向要插入节点node
			this.size++;	//修改size
		}
	}
	/**
	 * 向链表尾插入元素
	 * @param n
	 */
	public void addLast(Node n){
		this.add(n, this.size);
	}
	
	/**
	 * 删除链表中与节点n相同的节点
	 * @param n
	 */
	public void remove(Node n){
		if(head == null){
			System.out.println("链表为空，无元素可以删除。");
			return;
		}
		//1.删除的节点为头结点
		while(head.equals(n)){
			head = head.next;
			this.size--;
		}
		//2.删除的节点不是头结点
		Node cur = this.head;
		while(cur.next != null){
			if(cur.next.equals(n)){
				cur.next = cur.next.next;
				this.size--;
			}else{
				cur = cur.next;
			}
		}
	}
	/**
	 * 判断节点n是否在此链表中，在则返回true,否则返回false
	 * @param n
	 * @return
	 */
	public boolean contains(Node n){
		Node cur = this.head;
		while(cur != null){
			if(cur.equals(n)){
				return true;
			}else{
				cur = cur.next;
			}
		}
		return false;
	}
	/**
	 * 删除NodeLinkedList中不相似的点
	 * r为相似性阈值，如果大于r，则两点不相似，如果小于r则两点相似
	 */
	public void deleteDissim(double r){
		Node cur = this.head;
		while(cur.getNext() != null){
			double distance = this.head.computeSim(cur.getNext());
			if(distance > r){
				cur.next = cur.next.next;
				this.size--;
			}else{
				cur = cur.next;
			}
		}
		//删除后，更改头结点的度
		this.head.setDegree(this.size-1);
	}
	/**
	 * 用于测试
	 */
	public String toString(){
		StringBuffer sb = new StringBuffer();
		Node cur = this.head;
		while(cur != null){
			sb.append(cur.getId()+" -> ");
			cur = cur.getNext();
		}
		sb.append("null");
		return sb.toString();
	}
	
	public static void main(String[] args){
		Node n1 = new Node(1);
		Node n2 = new Node(2);
		Node n3 = new Node(3);
		Node n4 = new Node(4);
		Node n5 = new Node(5);
		
		NodeLinkedList nll = new NodeLinkedList();
		System.out.println(nll.getSize());
		nll.addFirst(n1);
		nll.addLast(n2);
		nll.add(n3, 2);
		nll.addLast(n4);
		nll.add(n5, 4);
		System.out.println(nll);
		Node n6 = new Node(5);
		System.out.println(nll.contains(n6));
		nll.addLast(n6);
		nll.remove(n6);
		System.out.println(nll);
		nll.remove(n1);
		System.out.println(nll);
		System.out.println(nll.getSize());
	}
}

解释：
      main方法是为了测试创建的类是否正确。
图类
代码：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 图类
 * 以ArrayList来保存图中的节点
 * 节点后的链接节点都是其在图中直接连接的节点
 * @author dxt
 *
 */
public class Graph {
	private List<NodeLinkedList> nodeList;
	private int size;	//图中的节点个数
	
	//构造方法
	public Graph(){
		super();
		this.nodeList = new ArrayList<NodeLinkedList>();
		this.size = 0;
	}
	
	//获取nodeList的长度
	public int getSize(){
		size = this.nodeList.size();
		return this.size;
	}
	//获取图的信息
	public List<NodeLinkedList> getNodeList(){
		return this.nodeList;
	}
	//构造图
	public void setNodeList(NodeLinkedList nll){
		this.nodeList.add(nll);
		this.size++;
	}
	/**
	 * 依据id获取对应id节点，此节点指向空
	 * @param id
	 * @return
	 */
	public Node getNLLNode(int id){
		for(int i=0; i<this.nodeList.size(); i++){
			if(id == this.nodeList.get(i).getHead().getId()){
				return this.nodeList.get(i).getHeadNode();
			}
		}
		return null;
	}
}

解释：
      只展示图类的基本结构，没有添加功能方法，即上面展示的代码并不全。在以后的介绍中会向此图类中添加方法，以实现社区挖掘算法。

构造空间图

代码：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 图类
 * 以ArrayList来保存图中的节点
 * 节点后的链接节点都是其在图中直接连接的节点
 * @author dxt
 *
 */
public class Graph {
	private List<NodeLinkedList> nodeList;
	private int size;	//图中的节点个数
	
	//构造方法
	public Graph(){
		super();
		this.nodeList = new ArrayList<NodeLinkedList>();
		this.size = 0;
	}
	
	//获取nodeList的长度
	public int getSize(){
		size = this.nodeList.size();
		return this.size;
	}
	//获取图的信息
	public List<NodeLinkedList> getNodeList(){
		return this.nodeList;
	}
	//构造图
	public void setNodeList(NodeLinkedList nll){
		this.nodeList.add(nll);
		this.size++;
	}
	/**
	 * 依据id获取对应id节点，此节点指向空
	 * @param id
	 * @return
	 */
	public Node getNLLNode(int id){
		for(int i=0; i<this.nodeList.size(); i++){
			if(id == this.nodeList.get(i).getHead().getId()){
				return this.nodeList.get(i).getHeadNode();
			}
		}
		return null;
	}
	
	public void initial(File nodeSrc, File edgeSrc){
		//1.首先读取节点文件，初始化各个节点，作为NodeLinkedList的头结点
		int index = 0;	//记录共有多少个节点
		BufferedReader br_node = null;
		try {
			br_node = new BufferedReader(new FileReader(nodeSrc));
			//1.1 读取数据
			String line = null;
			int id;
			double x;
			double y;
			int degree;
			while((line = br_node.readLine()) != null){
				//1.1.1 获取每一行数据的内容，并分割
				String[] datas = line.split("\t");
				id = Integer.valueOf(datas[0]);
				x = Double.valueOf(datas[1]);
				y = Double.valueOf(datas[2]);
				degree = Integer.valueOf(datas[3]);
				
				//1.2初始构造nodeList，nodeList中的每个NodeLinkedList只含有头结点
				//1.2.1 首先构造Node
				Node temp_node = new Node(id, x, y, degree, index);
				index++;
				//1.2.2构造NodeLinkedList
				NodeLinkedList temp_nll = new NodeLinkedList(temp_node);
				//1.2.3初始构造nodeList
				this.nodeList.add(temp_nll);
			}
			
			br_node.close();
			this.size = index;	//初始化size
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e){
			e.printStackTrace();
		}
		
		//2. 读取边文件，构造nodeList中的每一个NodeLinkedList
		BufferedReader br_edge = null;
		try {
			br_edge = new BufferedReader(new FileReader(edgeSrc));
			//2.1 读取边的信息
			String line = null;
			int id_one, id_two;
			Node n_two = null;
			int id_one_pre = -1;	//保存上一行数据中的id_one,初始设为-1， 提高构造效率效率
			int add_index = -1;	//维持一个索引，充分利用ArrayList的特点来提高效率
			while((line=br_edge.readLine()) != null){
				//2.1.1获取每一行的数据，并分割
				String[] datas = line.split("\t");
				id_one = Integer.valueOf(datas[0]);
				id_two = Integer.valueOf(datas[1]);
				
				//2.2 构造每一个NodeLinkedList
				//2.2.1 首先依据id_two找到对应的Node
				n_two = this.getNLLNode(id_two);
				
				//2.2.2 然后找到对应的NodeLinkedList,将n_two添加到NodeLinkedList中
				if(n_two != null){
					if(id_one != id_one_pre){
						for(int i=0; i<this.nodeList.size(); i++){
							if(id_one == this.nodeList.get(i).getHead().getId()){
								this.nodeList.get(i).addLast(n_two);	//将n_two添加到NodeLinkedList中
								add_index = i;
								break;
							}
						}
					}else{
						this.nodeList.get(add_index).addLast(n_two);
					}
				}
				//2.2.3 更新id_one_pre
				id_one_pre = id_one;
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e){
			e.printStackTrace();
		}
	}
	
	//用于测试是否已构建图，图是否正确
	public static void main(String[] args){
		File nodeSrc = new File("src//source//brightkite_nodes_available.txt");
		File edgeSrc = new File("src//source//brightkite_edges_available.txt");
		Graph g = new Graph();
		g.initial(nodeSrc, edgeSrc);
		System.out.println(g.getSize());
	}
}

解释：
      其中initial(File f1, File f2)方法就是根据点文件f1和边文件f2两个文件构造一个图。
      具体的思想是：先依据点文件构造出每个链表的头结点，然后依据边文件向头结点所在的链表插入节点。

dxt_snow
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于C++和JavaScript实现网络图的构建
毕业作品网站
07-06 516
1.网络图的构建2.核心算法的实现3.算法可视化图分析大作业实验文档操作系统：windows10（版本号1607）IDE:visualstudio2015HTML编辑：火狐浏览器编程语言：C++，JavaScript邵钰杉：数据采集王泽润：可视化张迁瑞：算法部分1.节点间的最短路径输入任意两个结点，可以输出结点间的最短路径(path:x-y-z)和这条最短路径的权值(weight),使用了Dijkstra算法。2.最小生成树对于给定的图，可以输出该图的最小生成树，输出结果是最小生成树边的个数和这些边的起点与
如何使用网络图构造进度管理模型(转)
cqwmy840702的博客
08-16 642
如何使用网络图构造进度管理模型使用PERT进行项目进度管理，是目前使用的比较多、也比较成熟的一种方法。本文着重从技术角度出发，从基本条件入手，结合PERT的基本概念，分析了如何使用网络图来构造进度管理模型，最后给出了网络优化的方...
利用PYG搭建数据集（同构图）
最新发布
weixin_46348136的博客
05-21 371
仅记录个人学习
空间连接时计算总和_连接、空间连接与关联(示例代码)
weixin_36300831的博客
12-23 357
一、连接1、通常会根据在这两个表中均可找到的字段值将数据表连接到图层。这一字段的名称可以不同，但数据类型必须相同。例如，必须将数字连接到数字，将字符串连接到字符串。2、支持一对一、多对一的关系。在 ArcMap 中连接表时，将在图层属性表(即目标表)和包含要连接的信息的表(关联表)之间建立一对一或多对一的关系。3、使用存在一对多或多对多关系的数据时，应使用关联或关系类来建立数据集之间的关系。但是，...
图神经网络的图网络学习（上）
m0_50976935的博客
10-15 799
图神经网络 (GNN) 在许多使用图结构数据的场景中取得了巨大成功。然而，在许多实际应用中，在应用 GNN 时存在三个问题：图未知、节点具有噪声特征以及图包含噪声连接。为了解决这些问题，我们提出了一种新的图神经网络，称为 GL-GNN。我们的模型包括多个子模块，每个子模块选择重要的数据特征，并在图未知时学习数据样本对应的关键关系图。GL-GNN 通过学习子模块的网络进一步得到图的网络。使用图网络上的聚合方法进一步融合学习到的图。
【数据结构】图——网络模型的基础
weixin_46318945的博客
11-21 553
图是一种相对复杂的数据结构由顶点和连接每队顶点的边构成的图形就是图。 1. 基础背景 假设你居住在旧金山，要从双子峰前往金门大桥。你想乘公交车前往，并希望换乘最少。可以做的公交车如下所示： 为了找到换乘最少的乘车路线，你将用什么样的算法？ 一步就能到达金门大桥吗？下面突出了所有一步就能到达的地方。 金门大桥未突出，因此一步无法到达那里，两步能吗？ 金门大桥也未突出，因此两步无法到达那里，三步呢？ 金门大桥突出了！因此从双子峰出发，可以沿下面的路线三步到达金门大桥。 ...
1.4卷积神经网络
01-19
在深度学习中，CNN和RNN等都可以被构建为判别式网络，用于分类或回归任务。 1.7 深度学习的应用 深度学习已广泛应用于各个领域，包括图像识别、语音识别、自然语言处理、推荐系统、自动驾驶等。其中，CNN在图像识别...
在线地图1.4maponline.rar
12-23
4. **空间分析**：作为GIS工具，MapOnline可能会提供一系列的空间分析功能，如缓冲区分析、网络分析、地形分析等，帮助用户解决实际问题。 5. **交互式地图制作**：可能提供用户友好的界面，使非专业人员也能创建...
1.3深度神经网络
01-19
本主题将深入探讨深度学习与神经网络的基本概念，以及它们如何构建起深度神经网络。 首先，我们从神经元的工作原理开始。神经元是生物神经系统的基本单位，它能接收信号并传递信息。在人工神经网络中，神经元被模拟...
项目4--网络服务器构建.ppt
03-26
* Windows Server 2008的安装硬件要求：处理器最低1.4GHz（x64处理器），内存最低512MB，硬盘分区要具有足够的可用空间，DVD-ROM等。 二、Windows Server 2008的安装步骤 * 启动计算机时，在自检的过程中按F9键，...
nnglib1.4x64.rar
01-27
《nnglib1.4x64：CMake构建与Windows x64调试及发布版本DLL详解》 在IT行业中，动态链接库（DLL）是Windows操作系统中的一个重要组成部分，它允许多个程序共享同一块内存中的代码和数据，从而节省系统资源。本篇将...
数据结构-图-知识网络//拒绝遗忘
weixin_43124546的博客
04-29 286
图的定义 1、图是逻辑结构 2、图是有边集点集组成的集合 图的概念 1、连通图：无向图，各个顶点有路径存在 2、强连通图：有向图，各个顶点有路径存在 3、联通分量：无向图的极大联通子图 4、极大联通子图：1、联通，2、极大，在加一个点就不连通 5、极小联通子图：1、联通，2、极小，在加一个边就有环 6、生成树：1、联通，2、极小联通子图，3、，包括所有的顶点，4、含有的边数最少 7、生成森林：菲联...
Python 20190208读入txt并做网络关系图（1）
jlzhoured的博客
02-08 3634
1.主要库 networkx 与 pyplot 2. 注意检查文本文档不要有多余空格，使用strip删除行尾回车，使用split进行列表划分 3. 使用addedge添加边，目前尚无增加节点与边的标签 import networkx import matplotlib.pyplot as plt df1 = open(‘dianqi_edge.txt’,‘r’) ncols1 = len(next...
1.3 Brightkite数据集处理
dxt_snow的博客
06-05 1258
1.3 数据处理目的处理代码处理结果 目的 处理代码 处理结果
matlab画多层网络图,复杂网络建模 社交网络图的一些计算代码（不全欢迎补充）MATLAB...
weixin_32620265的博客
03-17 2499
function [C,aver_C,max_C,min_C]=Clustering(A)%%求聚类系数%A--------------邻接矩阵%C--------------聚类系数%aver_C---------整个网络图的平均聚类系数A=xlsread('name.xls');%A=xlsread('hometown.xls');%A=xlsread('dialect.xls');N=s...
构建复杂网络的几种方法（邻接矩阵，邻接表，十字链表，邻接多重表）
qq_32515081的博客
04-12 9384
通常意义下的链表有单链表，双向链表，循环链表等，而复杂网络每个节点可能会同时指向任意个节点，从数据结构上来说两者是不同的。所以首先我们先认识一下数据结构有哪些。 数据结构有很多种，一般来说，按照数据的逻辑结构对其进行简单的分类，包括线性结构和非线性结构两类。 线性结构 简单地说，线性结构就是表中各个结点具有线性关系。如果从数据结构的语言来描述，线性结构应该包括如下几点： 1、线性结构是非空集。 2、线性结构有且仅有一个开始结点和一个终端结点。 3、线性结构所有结点都最多只有一个直接前驱结点和一个直
图数据集的构建
chumingqian的博客
05-18 649
官方文档， 介绍如何创建图数据集尽管 PyG 已经包含许多有用的数据集，但您可能希望使用自记录或非公开可用的数据创建自己的数据集。自己实现数据集很简单，您可能需要查看源代码以了解各种数据集是如何实现的。但是，我们简要介绍了设置自己的数据集所需的内容。
C语言构建网络包,R语言igraph 包-构建网络图(示例代码)
weixin_35075144的博客
05-28 740
igaph 是一个项目，目标是建立一条简单，易用的网络分析工具，有 R, python, C/C++ 等语言的具体实现；项目主页：http://igraph.org/在R语言中，对应的就是 igraph 这个R包安装：install.packages("igraph")使用：对于图 graph 这种数据结构而言，最基本的元素包括节点(node) 和 边(节点之间的连线，edge);igraph 这...
networkx学习笔记1：网络图创建
墨竹
02-27 3921
创建一个无标度网络G，随机生成节点：# -*-coding:utf-8-*-import networkx as nx import matplotlib.pyplot as pltG = nx.random_graphs.barabasi_albert_graph(100, 1) # 生成一个BA无标度网络G nx.draw(G) # 绘制网络G plt.savefig("ba.png")
百度地图JavaScript API v1.4 开发指南
3. **版本说明**：v1.4版的更新内容包括新增效果图和移动开发DEMO，以及对工具类的完善介绍。 4. **基础知识** - **百度地图的“Hello,World”**：介绍如何创建一个简单的地图展示，包括设置页面、引用API文件、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值