NJUPTN南邮 | 离散数学_实验四

内容：
对具有n个结点的无向图，判断其能否被一笔画。
要求：
对给定n个结点的无向图，进行欧拉图和半欧拉图的判定，若是欧拉图或半欧拉图，则输出所有的欧拉（回）路。

package exp04;

import java.util.Stack;

class Graph {
    int[][] matrix;     // 图的邻接矩阵
    int n;      // 顶点个数
    boolean[] visted;  //标记点是否被访问
    Stack<Integer> s=new Stack();       // 堆栈
    int[] ans=new int[50];
    int count = 0;  //记录欧拉路的路径，路径数

    public Graph(int[][] matrix, int n) {
        this.matrix = matrix;
        this.n = n;
        visted = new boolean[n];
        for (boolean v: visted) {
            v=false;
        }
    }

    //从所设定的起点深度优先遍历图，若有一个点没被访问，则为非连通图
    public boolean Judge()
    {
        DFS(0);
        for(int i = 0; i < n; i++)
            if(!visted[i])
                return false;
        return true;
    }

    //深度优先搜索
    private void DFS(int x)
    {
        visted[x] = true;
        for(int i = 0; i < n; i++)
            if(!visted[i] && matrix[x][i]==1)
                DFS(i);
    }

    public void JudgeEuler(){
        int degree,start=0,num=0;
        for(int i = 0; i < n; i++)      // 如果存在奇度顶点，则从奇度顶点出发，否则从0出发
        {
            degree = 0;
            for(int j = 0; j < n; j++)
                degree += matrix[i][j];
            if(degree % 2!=0)
            {
                start = i;
                num++;
            }
        }
        // 无向图具有一条欧拉路，当且仅当G是连通的，且有0个或2个奇数度结点
        if(num == 0 || num == 2)
        {
            Fleury(start);
            //欧拉路径的头和尾相等，则说明欧拉路是回路
            if(ans[0] == ans[count - 1])
                System.out.println("该图是欧拉图，欧拉回路为：");
            else
                System.out.println("该图是半欧拉图，欧拉路为：");
            Answer();
        }
        else
            System.out.println("该图不是欧拉图或半欧拉图");

    }

    private void Answer() {
        for(int i = 0; i < count; i++)
            System.out.print(ans[i]+" ");
        System.out.println();
    }

    private void Fleury(int x) {
        int flag;
        s.push(x);
        while(!s.isEmpty())
        {
            flag = 0;
            for(int i = 0; i < n; i++)
            {
                if(matrix[s.lastElement()][i] > 0)
                {
                    flag = 1;
                    break;
                }
            }
            if(flag == 0)  //如果没有可扩展的点，则记录下该点并将其出栈
            {
                ans[count ++] = s.pop() + 1;
            }
            else  //如果有，则将其出栈并继续搜索
            {
                DFSGraph(s.pop());
            }
        }
    }

    private void DFSGraph(int x)
    {
        s.push(x);
        for(int i = 0; i < n; i++)
        {
            if(matrix[i][x] > 0)
            {
                matrix[i][x] = 0;  //删除该边
                matrix[x][i] = 0;
                DFSGraph(i);
                break;
            }
        }
    }
}

package exp04;

import java.awt.*;
import java.util.Scanner;

public class Test04 {
    public static void main(String[] args) {
        System.out.println("请输入无向图节点个数：");
        Scanner input = new Scanner(System.in);
        int n=input.nextInt();     // 无向图节点个数
        System.out.println("请输入所需判定的无向图邻接矩阵：");
        int[][] matrix=new int[n][n];

        System.out.print(" ");
        for (int i = 1; i <=n; i++) {
            System.out.print(" "+i);
        }
        System.out.println();

        for (int i = 0; i < n; i++) {       // 输入图的邻接矩阵
            System.out.print(i+1);
            for (int j = 0; j < n; j++) {
                matrix[i][j]=input.nextInt();
            }
        }
        Graph g = new Graph(matrix,n);
        System.out.println(g.Judge()?"此图为连通图":"此图为非连通图");
        if (g.Judge()==false)       // 如果是非连通图，不需要进一步判断
            return;
        g.JudgeEuler();
    }
}