图的存储，搜索，遍历，广度优先算法和深度优先算法，最小生成树-Java实现

1）用邻接矩阵方式进行图的存储。如果一个图有n个节点，则可以用n*n的二维数组来存储图中的各个节点关系。

对上面图中各个节点分别编号，ABCDEF分别设置为012345。那么AB AC AD 关系可以转换为01 02 03， BC BE BF 可以转换为12 14 15， EF可以转换为45。换句话所，我们将各个节点关系存储在一个n*n的二位数组中，数组下标分别对应A-F，有关系的两个节点，在数组中用1表示，否则用0表示。这上图关系可以用6*6数组表示为：

2）深度优先进行图的遍历以及将图转换为最小生成树

深度优先的原则是从根节点开始，依次寻找后继的第一个子节点，直到没有后继为止。然后回到根节点，寻找根的第二个子节点，然后再依次寻找他的后继，直到没有后继为止。以此类推，直到所有节点都被遍历为止。实现深度优先遍历，有一个回朔的过程，所以需要用栈这种数据结构。

3）广度优先进行图的遍历以及将图转换为最小生成树

广度优先原则是从根节点开始，先将根的所有后继找出来，然后依次将所有后继的后继再找出来。以此类推，直到所有元素节点都被遍历。实现广度优先，是一个顺序过程，所以这里需要用到队列或者链表这种数据结构。

下面是代码实现:

package org.lyk.impl;

import java.util.ArrayList;
import java.util.Queue;
import java.util.Stack;

public class Graph
{
    private class Node
    {
        private boolean wasVisited;
        private char data;
        
        public Node(char data)
        {
            this.data = data;
            this.wasVisited= false;
        }
    }
    
    private Node[] nodes;
    private int[][] adjMetrix;
    private int maxSize;
    private int index;
    public Graph()
    {
        this.maxSize = 6;
        this.index = 0;
        this.nodes= new Node[this.maxSize];
        this.adjMetrix = new int[this.maxSize][this.maxSize];
    }
    
    /**
     * 增加节点
     * @param data
     * @throws Exception
     */
    public void add(char data) throws Exception
    {
        if(this.index >= this.maxSize)
        {
            throw new Exception("数组已满");
        }
        else
        {
            this.nodes[index++]= new Node(data);
        }
    }
    
    /**
     * 设置图中各个节点关系
     * @param x
     * @param y
     * @throws Exception
     */
    public void setRelation(int x,int y) throws Exception
    {
        if(x < this.maxSize && y < this.maxSize)
        {
            this.adjMetrix[x][y] = 1;
            this.adjMetrix[y][x] = 1;
        }
        else
        {
            throw new Exception("下标错误!");
        }
    }
    
    /**
     * 广度优先对图进行遍历
     * @param x
     * @throws Exception
     */
    public void showBreathFirst(int x) throws Exception
    {
        if(x >= 0 && x < this.index)
        {
            java.util.List<Integer> list = new java.util.ArrayList<>();
            int current = 0;
            list.add(x); 
            this.nodes[list.get(current)].wasVisited = true;
            while(current < list.size())
            {
                System.out.println(this.nodes[list.get(current)].data); 
                
                int nextSuccessor = this.getNextSuccessor(list.get(current));
                while(nextSuccessor != -1)
                {
                    list.add(nextSuccessor);
                    this.nodes[nextSuccessor].wasVisited = true;
                    nextSuccessor = this.getNextSuccessor(list.get(current));
                }
                current++;
            }
            
            this.resetNodes();
        }
        else
        {
            throw new Exception("下标越界");
        }
    }
    
    /**
     * 深度优先对图进行遍历
     * @param x
     * @throws Exception
     */
    public void showDeepFirst(int x) throws Exception
    { 
        if(x < this.index && x >= 0)
        {
            Stack<Integer> stack = new Stack<>();
            stack.push(x);
            System.out.println(this.nodes[x].data);
            this.nodes[x].wasVisited = true;
            while(!stack.isEmpty())
            {
                int temp = stack.peek();
                int nextSuccessor = this.getNextSuccessor(temp);
                if(nextSuccessor == -1)
                {
                    stack.pop();
                }
                else
                {
                    stack.push(nextSuccessor);
                    System.out.println(this.nodes[nextSuccessor].data);
                    this.nodes[nextSuccessor].wasVisited = true;
                }
            }
            this.resetNodes();
        }
        else
        {
            throw new Exception("下标错误");
        }
        
        
    }
    
    /**
     * 广度优先-最小生成树
     * @param x
     * @throws Exception
     */
    public void toMSTBreathFirst(int x ) throws Exception
    {
        if(x >= 0 && x < this.index)
        {
            java.util.List<Integer> list = new java.util.ArrayList();
            int current = 0;
            list.add(x);
            this.nodes[list.get(current)].wasVisited = true;
            while(current < this.index)
            {
                int successor = this.getNextSuccessor(list.get(current));
                while(successor != -1)
                {
                    list.add(successor);
                    System.out.println(this.nodes[list.get(current)].data + "->" + this.nodes[successor].data);
                    this.nodes[successor].wasVisited = true;
                    successor = this.getNextSuccessor(list.get(current));
                }
                current++;
            }
        }
        else
        {
            throw new Exception("下标错误");
        }
    }
    
    /**
     * 深度优先求最小生成树
     * @param x
     * @throws Exception
     */
    public void toMSTDeepFirst(int x) throws Exception
    {
        if(x < this.index && x >=0)
        {
            Stack<Integer> stack = new Stack<Integer>();
            stack.push(x);
            this.nodes[x].wasVisited = true;
            while(!stack.isEmpty())
            {
                int current = stack.peek();
                int nextSuccessor = this.getNextSuccessor(current);
                if(nextSuccessor == -1)
                {
                    stack.pop();
                }
                else
                {
                    stack.push(nextSuccessor);
                    this.nodes[nextSuccessor].wasVisited = true;
                    System.out.print(this.nodes[current].data);
                    System.out.print("-");
                    System.out.print(this.nodes[nextSuccessor].data);
                    System.out.print(" ");
                }
            }
            
            this.resetNodes();
        }
        else
        {
            throw new Exception("下标错误");
        }
    }
    
    private int getNextSuccessor(int x)
    { 
        for(int i = 0; i <this.maxSize; i++)
        {
            if(this.adjMetrix[x][i] != 0 && this.nodes[i].wasVisited == false)
            {
                return i;
            }
        }
        return -1;
    }
    
    private void resetNodes()
    {
        for(int i = 0; i < this.index; i++)
        {
            this.nodes[i].wasVisited = false;
        }
    }
}