算法学习图-优快云博客

本文链接：https://blog.youkuaiyun.com/syla_/article/details/144929355

图

存储方式：邻接矩阵、邻接表。（十字链表、邻接多重表，省空间但不常用）

类型：有向图、无向图

指定一种适合自己的存储方式，将各种表达方式转成自己熟悉的存储方式。
（如万物转邻接矩阵！）
下面是适用较广的模板

public class Graph{

    public HashMap<Integer, Node>nodes; //点集 编号+实际结构
    public HashSet<Edge> edges; //边集
    
    public Graph(){
        nodes=new HashMap<>();
        edges=new HashSet<>();
    }

}

public class Node{

    public int value;
    public int in; 
    public int out;
    public ArrayList<Node> nexts; //直接邻居 edges连向的结点
    public ArrayList<Edge> edges; //从当前结点出发的边
    
    public Node(int value){
        this.value=value;
        in=0;
        out=0;
        nexts=new ArrayList<>();
        edges=new ArrayList<>();
    }

}

public class Edge{

    public int weight;
    public Node from; 
    public Node to;
       
    public Node(int weight,Node from,Node to){
        this.weight=weight;
        this.from=from;
        this.to=to;
    }

}

BFS

队列+集合，队列实现BFS，集合实现不重复

public void BFS(Node node){
    if(node==null) return ; 
    Queue<Node> queue=new LinkList<>();
    HashSet<Node> set= new HashSet<>();
    queue.add(node);
    set.add(node);
    while(!queue.IsEmpty()){
        Node cur=queue.poll();
        process(cur);
        for(Node next:cur.nexts){
            //直接邻居未被访问过
            if(!set.contains(next)){
                queue.add(next);
                set.add(next);
            }
        }
    }

}

DFS

public void DFS(Node node){
    if(node==null) return ; 
    //路径在栈内，弹出访问下一结点后需要压回
    Stack<Node> stack=new LinkList<>();
    HashSet<Node> set= new HashSet<>();
    stack.push(node);
    set.add(node);
    process(node); //处理头
    while(!stack.IsEmpty()){
        Node cur=stack.pop();
        for(Node next:cur.nexts){
            //直接邻居未被访问过
            if(!set.contains(next)){
                //先压自己再压邻居，注册邻居
                stack.push(cur);
                stack.push(next);
                set.add(next);
                process(next);//处理邻居
                break;
            }
        }
    }

}

拓扑排序

找入度(in)为0的点

public static List<Node> sort(Graph graph){
        //key 某个node value剩余入度
        HashMap<Node, Integer> inMap=new HashMap<>();
        //入度为0进队列
        Queue<Node> zeroInQueue =new LinkedList<>();
        for(Node node:graph.nodes.values()){
            //nodes为ArrayList,values()方法获取值便于遍历
            inMap.put(node,node.in);
            if(node.in==0){
                zeroInQueue.add(node);
            }
        }
        //res 收集排序结果
        List<Node> res=new ArrayList<>();
        while(!zeroInQueue.isEmpty()){
            Node cur=zeroInQueue.poll();
            res.add(cur);
            //消除已排序点的影响
            for(Node next: cur.nexts){
                inMap.put(next,inMap.get(next)-1);
                if(inMap.get(next)==0){
                    zeroInQueue.add(next);
                }
            }
        }
        return res;

    }