地图绘制和四色算法，图搜索算法，最小生成树算法，最短路径算法

基于简易Web墨卡托计算实现地图绘制，四色染色，实现图的深度优先搜索，广度优先搜索，Kruskal算法最小生成树，Prime算法最小生成树，Dijkstra最短路径算法。

使用Java & Swing开发

基于简易Web墨卡托计算，地图绘制

四色定理染色：

	// 四色算法
	public void fill() {
		LinkedList<INode> source = (LinkedList<INode>)__nodes.clone();
		LinkedList<INode> target = new LinkedList<>();
		
		while (source.isEmpty() == false) {
			
			INode node = source.pop();
			target.push(node);
			
			boolean bContinue = false;
			do {
				INode top = target.peek();
				Color c = findColor(top);
				
				if (c == null) {
					INode n = target.pop();
					n.setColor(null);
					source.push(n);
					continue ;
				}
				
				top.setColor(c);
				bContinue = ! detect(top);
				
			} while (bContinue == false);
		}
		
	}

BFS优先搜索算法

	// 广度优先搜索
	public void bfs() {
		LinkedList<INode> all = (LinkedList<INode>)__nodes.clone();
		LinkedList<INode> q = new LinkedList<>();

		while (all.isEmpty() == false) {
			INode node = all.removeFirst();
			q.add(node);

			int p = 0;
			while (p < q.size()) {
				INode n = q.get(p);

				for (INode n1 : n.getChildren()) {
					boolean b = all.remove(n1);
					if (b)
						q.add(n1);
				}

				p++;
			}
		}

		__nodes.clear();
		__nodes.addAll(q);

	}

 

DFS深度优先搜索算法：

	// 深度优先搜索
	public void dfs() {
		LinkedList<INode> all = (LinkedList<INode>)__nodes.clone();
		LinkedList<INode> q = new LinkedList<>();
		
		while (all.isEmpty() == false) {
			INode node = all.removeFirst();
			q.add(node);

			_dfs(all, q, node);
		}

		__nodes.clear();
		__nodes.addAll(q);
	}
	
	private void _dfs(LinkedList<INode> all, LinkedList<INode> target, INode c) {
		for (INode n : c.getChildren()) {
			boolean b = all.remove(n);
			if (b) {
				target.add(n);
				_dfs(all, target, n);
			}
		}
	}

Kruskal最小生成树：

	public List<Edge> Kruskal() {
		HashSet<Edge> _edges = buildEdge();

		LinkedList<Edge> edges = new LinkedList<>();
		edges.addAll(_edges);

		Collections.sort(edges, new Comparator<Edge>() {
			@Override
			public int compare(Edge o1, Edge o2) {
				return o1.compareTo(o2);
			}
		});

		List<HashSet<INode>> range = new LinkedList<>();
		LinkedList<Edge> r = new LinkedList<>();

		for (Edge edge : edges) {
			HashSet<INode> s1 = null;
			HashSet<INode> s2 = null;

			for (HashSet<INode> s : range) {
				if (s.contains(edge.n1) == true) {
					s1 = s;
				}
				if (s.contains(edge.n2) == true) {
					s2 = s;
				}
				if (s1 != null && s2 != null)
					break ;
			}

			if (s1 != null && s2 != null) {
				if (s1 == s2)
					continue ;
				else {
					HashSet<INode> s = new HashSet<>();
					s.addAll(s1);
					s.addAll(s2);
					range.remove(s1);
					range.remove(s2);
					range.add(s);
					r.add(edge);
				}
			}
			if (s1 == null && s2 == null) {
				HashSet<INode> s = new HashSet<>();
				s.add(edge.n1);
				s.add(edge.n2);
				range.add(s);
				r.add(edge);
			}
			if (s1 != null && s2 == null) {
				s1.add(edge.n2);
				r.add(edge);
			}
			if (s1 == null && s2 != null) {
				s2.add(edge.n1);
				r.add(edge);
			}
		}

		return r;
	}

Prime最小生成树

	public List<Edge> Prime() {
		LinkedList<Edge> r = new LinkedList<>();
		LinkedList<INode> range = new LinkedList<>();

		range.add( this.randomNode() );

		while (true) {

			int min = -1;
			Edge minEdge = null;

			for (INode node : range) {
				for (INode child : node.getChildren()) {
					if (range.contains(child) == false) {
						Edge edge = new Edge(node, child);
						int w = Edge.getDistance(node, child);

						if (minEdge == null) {
							minEdge = edge;
							min = w;
						}
						else if (w < min) {
							minEdge = edge;
							min = w;
						}
					}
				}
			}

			if (minEdge != null) {
				range.add(minEdge.n1);
				range.add(minEdge.n2);
				r.add(minEdge);
			}
			else
				break ;
		}

		return r;
	}

Dijkstra算法

	// Dijkstra算法
	public List<Edge> Dijkstra() {

		for (int i=0; i<__nodes.size(); i++) {
			__nodes.get(i).setWeight(-1);
		}

		HashSet<Edge> edges = buildEdge();
		LinkedList<Edge> r = new LinkedList<>();
		LinkedList<INode> s = new LinkedList<>();
		LinkedList<INode> all = (LinkedList<INode>) __nodes.clone();

		INode starter = randomNode();
		starter.setWeight( 0 );
		s.add(starter);
		all.remove(starter);

		while (all.isEmpty() == false) {

			INode minNode = null;
			int minWeight = -1;
			Edge e = null;

			for (INode n1 : all) {
				for (INode n2 : s) {
					Edge edge = findEdge(edges, n1, n2);

					if (edge != null) {
						int d = n2.getWeight() + edge.getDistance();
						if (minNode == null) {
							minNode = n1;
							minWeight =d;
							e = edge;
						}
						else if (d < minWeight) {
							minNode = n1;
							minWeight = d;
							e = edge;
						}
					}
				}
			}

			if (minNode != null) {
				minNode.setWeight(minWeight);
				s.add(minNode);
				all.remove(minNode);
				r.add(e);
			}
			else
				break;
		}

		return r;
	}