Java 有向图中的欧拉圈问题

下面是我的代码，用于查找图在有向图中是否有欧拉圈。该代码适用于几种情况（我的main方法中的注释行有效）。但它确实适用于g1图（我的主方法中的未注释代码）。它说图（g1）没有欧拉电路，这是应该的。请帮我找出错误，谢谢

  import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Stack;


public class EulerianCirlsDirected {

        int v;
        Set<Integer> visitedDFS;
        int in[];
        HashMap<Integer,List<Integer>> adjList;
        public EulerianCirlsDirected(int v){
            this.visitedDFS = new HashSet<Integer>();
            this.adjList = new HashMap<Integer,List<Integer>>();
            this.v = v;
            in = new int[v];
        }

        //add edge
        public void addEdge(int src, int dest){
            List<Integer> srcNeighbour = this.adjList.get(src);
            if(srcNeighbour == null){
                this.adjList.put(src, srcNeighbour = new ArrayList<Integer>());
            }
            srcNeighbour.add(dest);
            in[dest]++;
        }


        //get neighbours of vertex
        public Iterable<Integer> getNeighbours(Integer vertex){

            List<Integer> neighbours = this.adjList.get(vertex);
            if(neighbours == null){
                return Collections.emptyList();
            }
            else{
                return Collections.unmodifiableList(neighbours);
            }

        }

        public int sizeNeighbours(Integer vertex){

            List<Integer> list = (List<Integer>) this.getNeighbours(vertex);


            return list.size();
        }

        //depth first search
        public Iterable<Integer> DFS(Integer src){
            Stack<Integer> stack= new Stack<Integer>();
            List<Integer> paths = new ArrayList<Integer>();
            stack.add(src);
            visitedDFS.add(src);
            paths.add(src);

            while(!stack.isEmpty()){

                int ref = stack.pop();
                for(int neig : this.getNeighbours(ref)){
                    if(!visitedDFS.contains(neig)){
                        stack.add(neig);
                        visitedDFS.add(neig);
                        paths.add(neig);
                    }
                }


            }

            return Collections.unmodifiableSet(visitedDFS);
        }

        public int numVertices(){
            return this.v;
        }

        //transpose of graph
        public EulerianCirlsDirected getTranspose(){

            int v = this.numVertices();
            EulerianCirlsDirected gr = new EulerianCirlsDirected(v);
            for(int i=0; i<v;i++){
                for(int neig:this.getNeighbours(i)){
                    gr.addEdge(neig, i);
                }
            }
            return gr;

        }

        //checks if graph has a eulerian cycle
        public boolean isEulerianCycle(){
            int v = this.numVertices();

            //check if graph is connect
            //that is every non zero degree vertex is part 
            //of a strongly connected component
            if(!isConnected()){
                return false;
            }

            //check for indegree and out degree
            for(int i=0;i<v;i++){
                if(in[i] != this.adjList.get(i).size()){
                    return false;
                }
            }

            return true;

        }

        //method to verify for strongly connected component
        public boolean isConnected(){

            int v =this.numVertices();
            int i;

            //get the first non zero degre vertex
            for( i=0; i<v;i++){
                if(this.sizeNeighbours(i)>0){break;}
            }

            //first run dfs for original graph at the first non
            //zero degree vertex
            this.DFS(i);

            //check if all vertices where visited during dfs
            for(int j=0;j<v;j++){
                if(!visitedDFS.contains(j)){
                    System.out.println("first " +visitedDFS.contains(j));
                    return false;
                }

            }

            //get transpose of graph and run dfs
            //so we have to reset visitedDFS
            visitedDFS.clear();
            EulerianCirlsDirected gr = this.getTranspose();

            //update visitedDFS to be that of the 
            //transpose
            visitedDFS= (Set<Integer>) gr.DFS(i);

            //check again if all vertices are visited in the 
            //transposed graph

            int grV = gr.numVertices();
            for(int j=0;j<grV;j++){
                if(!visitedDFS.contains(j)){
                    return false;
                }

            }
            return true;

        }
        public static void main(String[]args){

    //          EulerianCirlsDirected g = new EulerianCirlsDirected(2);
    //          g.addEdge(0, 1);
    //          g.addEdge(1, 0);
    //          g.addEdge(2, 3);
    //          g.addEdge(3, 0);
    //          g.addEdge(2, 4);
    //          g.addEdge(4, 2);

            EulerianCirlsDirected g1 = new EulerianCirlsDirected(26);
            g1.addEdge(6, 10);
            g1.addEdge(10, 6);
            System.out.println(g1.isEulerianCycle());
            //System.out.println(g.sizeNeighbours(1));

        }

    }

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.HashMap；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Set；
导入java.util.Stack；
公共类欧拉指令{
INTV；
设置已访问的DFS；
[]中的int；
哈希表；
公共EULERANCIRLSDirected（int v）{
this.visitedDFS=new HashSet（）；
this.adjList=newhashmap（）；
这个，v=v；
in=新的整数[v]；
}
//添加边
公共无效补遗（int src，int dest）{
List srcnee邻=this.adjList.get（src）；
if（srcnee邻==null）{
this.adjList.put（src，srcneaxture=newarraylist（））；
}
src.add（dest）；
在[dest]++；
}
//得到顶点的邻域
公共Iterable GetNeights（整数顶点）{
列表邻居=this.adjList.get（顶点）；
if（邻居==null）{
返回集合。emptyList（）；
}
否则{
返回集合。不可修改列表（邻居）；
}
}
公共整数sizeNeighbours（整数顶点）{
List=（List）this.getNeights（顶点）；
返回list.size（）；
}
//深度优先搜索
公共Iterable DFS（整数src）{
堆栈=新堆栈（）；
列表路径=新的ArrayList（）；
stack.add（src）；
访问dfs.add（src）；
添加路径（src）；
而（！stack.isEmpty（））{
int ref=stack.pop（）；
for（int neig:this.getneights（ref））{
如果（！visitedDFS.contains（neig））{
叠加（neig）；
访问dfs.add（neig）；
路径。添加（neig）；
}
}
}
返回集合。不可修改集（visitedDFS）；
}
公共整数{
归还这个；
}
//图的转置
公共EulerianCirlsDirected getTranspose（）{
int v=this.numVertices（）；
EulerianCirlsDirected gr=新的EulerianCirlsDirected（v）；
对于（int i=0；i当您使用26构造EulerianCirlsDirected时，您的代码预期将有26个顶点，并且它们都将被DFS触及

替换

EulerianCirlsDirected g1 = new EulerianCirlsDirected(26);
g1.addEdge(6, 10);
g1.addEdge(10, 6);

与

它会起作用的

或者，每次从0到v迭代时，检查
this.sizeNeighbours（i）>0
。在
isConnected（）
中两次，在
isurleriancycle（）中一次
Hey@Misha谢谢你的帮助，但在我想解决的问题中，我想在顶点6和10之间创建一条边。因此，创建一个只有两个顶点的图是行不通的，所以请看我的答案的第二部分。每当你为（I=0；I 0）{…}

EulerianCirlsDirected g1 = new EulerianCirlsDirected(2);
g1.addEdge(0, 1);
g1.addEdge(1, 0);