java的vertex的简单介绍

本篇文章给大家谈谈java的vertex，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、JAVA：hashmap根据自定义类型的属性排序
• 2、一个有关于java的算法问题，求高手协做
• 3、java如何把有换行的字符串弄到一行显示？
• 4、java如何从List中取值
• 5、JAVA求10个景点间各个景点的最短路径 图随便话 距离随便 求代码

JAVA：hashmap根据自定义类型的属性排序

是自己做这个算法么，还是要用到java的数据结构，因为hashmap是无序的，Treemap是有序的，但是他们排序不是看value是看key的，是必须这样做么，因为我想如果你用hashMap你是用key来访问里面value的，排不排序意义不大，我建议用TreeSet排序，如果你需要用name就直接遍历set的时候取name就完了，如果不想改变原来的类的结构，就用list加comparator做，如果还是要用map就把排好序的set或list以name为key再放到map里

一个有关于java的算法问题，求高手协做

//参考别人的,自己就懒得写了,你拿去参考参考...

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

public class Dijkstra {

private int[][] graph;// 加权有向图

private int start;// 源点编号 从 0开始

private int dimention;

static int INF = Integer.MAX_VALUE / 100;

// 用于标记顶点是否已经计算

private SetInteger vertexSet = new HashSetInteger();

// 存储结果，Map的key对应各终点编号，value对应路径编号列表。

private MapInteger, ListInteger pathListMap = new HashMapInteger, ListInteger();

public Dijkstra(int[][] graph, int start) {

this.graph = graph;

this.start = start;

this.dimention = graph.length;

calculate();

}

private void calculate() {

// 初始化

for (int end = 0; end dimention; end++) {

if (end == start) {

continue;

}// 起始点自己的路径排除。

ListInteger pathList = new ArrayListInteger();

pathList.add(start);// 每条路径的起始点都为start，pathList只记录编号，不记录路径权值

pathList.add(end);// 每条路径的第二个参数为终点编号

pathListMap.put(end, pathList);

}

// 计算主体

for (int bridge = 0; bridge dimention; bridge++) {

if (bridge == start) {

continue;

}

if (!vertexSet.contains(bridge)) {// 确保每个基点只循环计算一次

for (int next = 0; next dimention; next++) {

if (next == start || next == bridge) {

continue;

}

if (startTo(bridge) + getRawLength(bridge, next) startTo(next)) {

ListInteger pathList = pathListMap.get(next);

ListInteger bridgePathList = pathListMap.get(bridge);

// 清空，使用新的

pathList.clear();

pathList.addAll(bridgePathList);

pathList.add(next);

}

}

}

vertexSet.add(bridge);

}

// 检查，是否桥接的路径都被更新

for (int end = 0; end dimention; end++) {

if (end == start) {

continue;

}

ListInteger pathList = pathListMap.get(end);

int size = pathList.size();

if (size 2) {

for (int end2 = 0; end2 dimention; end2++) {

int isEnd = pathList.get(size - 2);

if (end2 == isEnd) {

pathList.clear();

pathList.addAll(pathListMap.get(end2));

pathList.add(end);

}

}

}

}

}

private int startTo(int end) {

int pathLen = 0;

ListInteger pathList = pathListMap.get(end);

for (int i = 0; i pathList.size() - 1; i++) {

pathLen += graph[pathList.get(i)][pathList.get(i + 1)];

}

return pathLen;

}

private int getRawLength(int start, int end) {

if (end == start) {

return 0;

}

return graph

本篇文章给大家谈谈java的vertex，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

java的vertex的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、java的vertex的信息别忘了在本站进行查找喔。

}

public int getLength(int end) {

if (end == start) {

return 0;

}

return startTo(end);

}

public void printResult() {

System.out.println(pathListMap);

}

public MapInteger, ListInteger getPathListMap() {

return pathListMap;

}

public static void main(String[] args) {

/*

* int [][] graph = { { INF, 10, INF, 30, 100}, { INF, INF, 50, INF,

* INF}, { INF, INF, INF, INF, 10}, { INF, INF, 20, INF, 60}, { INF,

* INF, INF, INF, INF}};

*/

int[][] graph = { { INF, INF, 10, INF, 30, 100 },

{ INF, INF, 5, INF, INF, INF },

{ INF, INF, INF, 50, INF, INF },

{ INF, INF, INF, INF, INF, 10 },

{ INF, INF, INF, 20, INF, 60 },

{ INF, INF, INF, INF, INF, INF }, };

int start = 0;

int end = 0;

int length = graph.length;

for (start = 0; start length; start++) {

System.out.println();

Dijkstra dijkstra = new Dijkstra(graph, start);

dijkstra.printResult();

for (end = 0; end length; end++) {

if (end == start) {

continue;

}

int len = dijkstra.getLength(end);

System.out.println(" Length(" + start + "-" + end + ") = "

+ ((len == INF) ? "Infinity" : len));

}

}

}

}

java如何把有换行的字符串弄到一行显示？

通过读该也页面的文件，读其实就是一个遍历的过程，通过字符串的叠加，可以把该页面的文件

变成一行

java如何从List中取值

如果是在同一个类里：

ListString pointList = generatePonits();

pointList.get(0); //获取第1个，以此类推

JAVA求10个景点间各个景点的最短路径 图随便话 距离随便 求代码

最有效，切不复杂的方法使用Breadth First Search (BFS). 基本代码如下（伪代码）。因为BFS不用递归，所以可能会有点难理解。

public Stack findPath(Vertex 起始景点, Vertex 目标景点){

Queue Vertex q = new QueueVertex();

s.enqueue(起始景点);

Vertex 当前位置;

while(!s.isEmpty()){

当前位置 = s.dequeue();

if (当前位置 == 目标景点) break;

for (每一个相邻于 当前位置 的景点 Vertex v){

if (!v.visited){

v.parent = 当前位置;

// 不是规定，不过可以节省一点时间

if (v == 目标景点){

current = v;

break;

}

s.enqueue(Vertex v);

v.visited = true;

}

}

}

Stack Vertex solution = new Stack Vertex();

Vertex parent = current;

while (parent != 起始景点){

solution.push(parent);

parent = current.parent;

}

for (graph中的每一个vertex) vertex.visited = false;

return solution(); // 其实这里建议用一个 Path 的inner class 来装所获得的路线

}

然后再 main 求每两个景点之间的距离即可

public static void main(String[] argv){

PathFinder pf = new PathFinder();

Stack[][] 路径 = new Stack[10][10];

for(int i=0; ipf.vertices.length; i++){

for(int j=i+1; jpf.vertices.length; j++){

Stack s = pf.findPath(pf.vertices[i], pf.vertices[j]);

路径[i][j] = s; 路径[j][i] = s; // 假设你的graph是一个undirected graph

}

}

// 这么一来就大功告成了！对于每两个景点n 与 m之间的最短路径就是在 stack[n][m] 中

}

还有一种方法就是用Depth First Search递归式的寻找路径，不过这样比较慢，而且我的代码可能会造成stack overflow

public Stack dfs(Vertex 当前景点，Vertex 目标景点){

if(当前景点 == 目标景点) return;

Stack solution = new Stack();

Stack temp;

for (相邻于 点钱景点 的每一个 Vertex v){

if (!v.visited){

v.visited = true;

temp = dfs(v, 目标景点);

// 抱歉，不记得是stack.size()还是stack.length()

if (solution.size() == 0) solution = temp;

else if(temp.size() solution.size()) solution = temp;

v.visited = false; 复原

}

}

return solution;

}

然后再在上述的Main中叫dfs...

参考：

java的vertex的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、java的vertex的信息别忘了在本站进行查找喔。