无向图（邻接表实现）

为什么采用邻接表实现？

因为在处理实际问题中，我们经常处理的是稀疏矩阵；

不可接受的；

实现类和方法：

1.点的定义；

2.图的构造方法；

3.增加点；

4.增加边；

5.删除边；

6.打印顶点表；

7.打印邻接表；

测试只用了5个点，主要是实现图；

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

/**
 * FileName: Graph
 * Author:   Jerry
 * Date:     2020/2/7 16:38
 * Description: 图及深度搜索和广度搜索
 */
package Graph_DFS_AND_BFS;
 
import java.util.*;
 
public class Graph {
    //图的顶点集合
    private Set<Vertex> vertexSet = new HashSet<Vertex>();
    //图的邻接表集合
    private Map<Vertex,List<Vertex>> vertexListMap=new HashMap<Vertex,List<Vertex>>();
    //空的构造函数
    public Graph(){
 
    }
    //带有参数的构造函数
    public Graph(Set<Vertex> set,Map<Vertex,List<Vertex>> vertexListMap){
        this.vertexSet=set;
        this.vertexListMap=vertexListMap;
        for(Vertex vertex:this.vertexSet){
            vertex.isVisiable=false;
        }//初始化
    }
    public Set<Vertex> getVertexSet(){
        return vertexSet;
    }
    public Map<Vertex,List<Vertex>> getVertexListMap(){
        return vertexListMap;
    }
    //插入边
    public void putEdge(Vertex vertex1,Vertex vertex2){
        if(!vertexSet.contains(vertex1)){
            vertexSet.add(vertex1);
            LinkedList<Vertex> vertexList1 =new LinkedList<Vertex>();
            vertexList1.add(vertex2);
            vertexListMap.put(vertex1,vertexList1);
        }
        else{
            vertexListMap.get(vertex1).add(vertex2);
        }
        if(!vertexSet.contains(vertex2)){
            vertexSet.add(vertex2);
            LinkedList<Vertex> vertexList2 = new LinkedList<Vertex>();
            vertexList2.add(vertex1);
            vertexListMap.put(vertex2,vertexList2);
        }
        else{
            vertexListMap.get(vertex2).add(vertex1);
        }
    }
    //插入点
    public void putVertex(Vertex vertex){
        if(vertexSet.contains(vertex))
            return;
        else{
            vertexSet.add(vertex);
            LinkedList<Vertex> vertexlist = new LinkedList<Vertex>();
            vertexListMap.put(vertex,vertexlist);
        }
    }
    //打印顶点集
    public void printVertex(){
        System.out.println("顶点集为：");
        for(Vertex vertex:vertexSet){
            System.out.print("  "+vertex.name);
        }
    }
    //打印邻接表
    public void printEdge(){
        System.out.println("邻接表为：");
        for(Vertex vertex:vertexSet){
            System.out.print("与"+vertex.name+"临接的点为：");
            List<Vertex> vertexList = getVertexListMap().get(vertex);
            if(vertexList!=null){
                for(Vertex vertex1:vertexList){
                    System.out.print(vertex1.name+" ");
                }
            }
            System.out.println();
        }
    }
    //删除边
    public void deleteEdge(Vertex vertex1,Vertex vertex2){
        if(!vertexSet.contains(vertex1)||!vertexSet.contains(vertex2)){
            System.out.println("输入错误！无法操作！");
            return;
        }
        getVertexListMap().get(vertex1).remove(vertex2);
        getVertexListMap().get(vertex2).remove(vertex1);
    }
    public boolean equal(Vertex vertex1,Vertex vertex2){
        if(vertex1.name==vertex2.name){
            return true;
        }
        else{
            return false;
        }
    }
    //删除点，复杂度较高，需要遍历邻接表，应该不会被使用
 
    //顶点类
    static class Vertex{
        int name;
        int weight;
        boolean isVisiable;
        Vertex(int data){
            this.name = data;
        }
    }
    public static void main(String []args){
        Graph graph = new Graph();
        Vertex vertex0 = new Vertex(0);
        Vertex vertex1 = new Vertex(1);
        Vertex vertex2 = new Vertex(2);
        Vertex vertex3 = new Vertex(3);
        Vertex vertex4 = new Vertex(4);
        graph.putEdge(vertex0,vertex1);
        graph.putEdge(vertex0,vertex2);
        graph.putEdge(vertex1,vertex3);
        graph.putEdge(vertex2,vertex3);
        graph.putVertex(vertex4);
        graph.deleteEdge(vertex1,vertex3);
        graph.printVertex();
        graph.printEdge();
    }
}