图的遍历,深度优先与广度优先详解

图采用邻接矩阵实现,深度优先搜索采用栈来实现,广度优先遍历采用队列来实现.附上代码详解.

---

图的实现

1.邻接矩阵实现

简单来说就是用一个二维数组来存储图之间的联通情况,比如有5个点,就可以用一个 5*5的 矩阵来存储 两点间是否联通.

比如上图 false 表示不连通, true表示连通.

public class Graph {    private boolean[][] map ;    private int length;    public Graph(int length)//生成图    {        this.length = length;        map = new boolean[length][length];    }    public void addEdge(int i,int j)//加边    {        if (map == null)        {            if (i>j)            {                map = new boolean[i][i];                length = i;            }            else            {                map = new boolean[j][j];                length = j;            }        }        map[i][j]  = true;        map[j][i]  = true;    }    public void removeEdge(int i,int j)//去边    {        if (map == null || j>=length||i>=length)            return;        else {            map[i][j] = false;            map[j][i] = false;        }    }    public boolean isEdge(int i,int j)//判断是否联通    {        if (map==null||i>=length||j>=length)            return false;        else            return true;    }}

这个为无向图,若为有向图,则生成的边只有一个就好,即只有A到B.

2.邻接链表实现

采用一个一维链表数组用来存储每个点.若这个节点与其他节点有联通,则与它相连通的子节点构成一个链表.

import java.util.ArrayList;/** * Created by max on 17-5-9. */public class ListGraph {    ListNode[] listNodes;    int length ;    ArrayList<Integer> vertices;    public ListGraph(int lenght)    {        this.length = lenght;        listNodes = new ListNode[length];        vertices = new ArrayList<>();        for (int i=0;i<length;i++)        {            listNodes[i] = new ListNode();            vertices.add(i);        }    }    public void addEdge(int start,int end)    {        int i = vertices.indexOf(start);        int j = vertices.indexOf(end);        if (j!=-1&&i!=-1)        {            listNodes[i].insertAtBeginning(j);            listNodes[j].insertAtBeginning(i);        }    }}

DFS深度优先搜索

思路是采用栈的用来存储访问的节点,而先进后出的机制刚好满足深度搜索的需求.给每个节点添加一个boolean属性,用于判断是否被访问过.

import java.util.ArrayList;import java.util.Stack;/** * Created by max on 17-5-9. */public class DFS {    private class Vertics    {        public char label;        public boolean visited;        public Vertics(char label)        {            this.label  = label;            visited = false;        }    }    private class Graph    {        private boolean[][] map;        private ArrayList<Vertics> vertices;        private  int countVertices;        private Stack<Integer> stack;        public Graph(int length)        {            stack = new Stack<>();            countVertices = 0;            vertices = new ArrayList<>();            map = new boolean[length][length];        }        public Graph()        {            stack = new Stack<>();            int length =20;            countVertices = 0;            vertices = new ArrayList<>();            map = new boolean[length][length];        }        public void addVertice(char label)        {            vertices.add(new Vertics(label));            countVertices++;        }        public void addEdge(int i,int j)        {            map[i][j] = true;            map[j][i] = true;        }        public void removeEdge(int i ,int j)        {            map[i][j] = false;            map[j][i] = false;        }        public void showLabel(int i)        {            System.out.print(" "+vertices.get(i).label);        }        public void dfs()        {            showLabel(0);            vertices.get(0).visited = true;            stack.push(0);            while(!stack.isEmpty())            {                int v =getNextNode(stack.peek());                if (v==-1)                {                    stack.pop();                }                else                {                    vertices.get(v).visited=true;                    showLabel(v);                    stack.push(v);                }            }            for (int i = 0 ;i<countVertices;i++)                vertices.get(i).visited=false;        }        private int getNextNode(int peek) {            for (int i = 0; i < countVertices; i++)            {                if (map[peek][i]==true&&vertices.get(i).visited==false)                    return i;            }            return -1;        }    }}

BFS广度优先搜索

广度优先搜索主要是通过队列的先进先出的机制来实现. 以JAVA中的ArrayQueue实现.

       public void bfs()        {            showLabel(0);            vertices.get(0).visited = false;            queue.add(0);            int ans;            int deal;            while(!queue.isEmpty())            {                deal = (int) queue.remove();                while ((ans = getNextNode(deal))!=-1)                {                    vertices.get(ans).visited=true;                    showLabel(ans);                    queue.add(ans);                }            }            for (int i = 0 ;i<countVertices;i++)                vertices.get(i).visited=false;        }

以上是笔主自己对 深搜广搜的理解与笔记,欢迎交流撕逼.