Java 如何将无向图的DFS时间复杂度O（V^2）更改为O（V+；E）或O（V+；2E）

为了改进我的算法，我尝试以O（V+2E）的时间复杂度编写DFS代码，但似乎我最终得到了O（V^2）。请帮我修复代码。我可以通过将其中一个while循环移动到一个子例程中来使用递归过程。这是解决问题的唯一办法，还是我们可以采取其他措施来解决

package com.dfs;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Stack;

public class MainMethod {

/**
 * @param args
 */

public static void main(String[] args) {
    List<List<Integer>> nodesList = new ArrayList<List<Integer>>();
    List<Integer> list1 = new ArrayList<>();
    List<Integer> list2 = new ArrayList<>();
    List<Integer> list3 = new ArrayList<>();
    List<Integer> list4 = new ArrayList<>();
    List<Integer> list5 = new ArrayList<>();
    List<Integer> list6 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    list2.add(3);
    list2.add(2);
    list3.add(3);
    list4.add(4);
    list5.add(5);
    list5.add(1);
    list5.add(0);
    nodesList.add(list1);
    nodesList.add(list2);
    nodesList.add(list3);
    nodesList.add(list4);
    nodesList.add(list5);
    nodesList.add(list6);

    //List to check vertext has been visted or not
    List<List<Integer>> vertexVisitCheck = new ArrayList();
    Stack<List<Integer>> tobeExplored = new Stack<>();
    System.out.println(nodesList);
    int startnode = 0;
    tobeExplored.push(nodesList.get(startnode));
    System.out.println("Added to the Stack ===> "+nodesList.get(startnode));
    while(!tobeExplored.isEmpty())
    {
        List<Integer> nextVertex = tobeExplored.peek();;
            vertexVisitCheck.add(nextVertex);
            Iterator<Integer> iterator = nextVertex.iterator();
            int counter = nextVertex.size();
            while (iterator.hasNext()) {
                int check =  iterator.next();
                if(!vertexVisitCheck.contains(nodesList.get(check)))
                {
                    tobeExplored.push(nodesList.get(check));
                    System.out.println("Added to the Stack ===> "+nodesList.get(check));
                    if(tobeExplored.peek().size()==0)
                    {
                        vertexVisitCheck.add(nodesList.get(check));
                        tobeExplored.pop();
                    }
                        break;
                }
                if(--counter==0)
                {
                    vertexVisitCheck.add(nodesList.get(check));
                    tobeExplored.pop();
                }       
          }
     }
 }

package com.dfs；
导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.Iterator；
导入java.util.List；
导入java.util.Map；
导入java.util.Random；
导入java.util.Stack；
公共类方法{
/**
*@param args
*/
公共静态void main（字符串[]args）{
List nodesList=new ArrayList（）；
List list1=新的ArrayList（）；
List list2=新的ArrayList（）；
List list3=新的ArrayList（）；
List list4=新的ArrayList（）；
List list5=新的ArrayList（）；
List list6=新的ArrayList（）；
清单1.添加（1）；
清单1.添加（2）；
清单2.添加（3）；
清单2.添加（2）；
清单3.添加（3）；
清单4.添加（4）；
清单5.添加（5）；
清单5.添加（1）；
清单5.添加（0）；
nodesList.add（列表1）；
nodesList.add（列表2）；
nodesList.add（列表3）；
nodesList.add（列表4）；
nodesList.add（列表5）；
nodesList.add（列表6）；
//检查vertext是否已访问的列表
List vertexVisitCheck=new ArrayList（）；
Stack tobeExplored=新堆栈（）；
System.out.println（节点列表）；
int startnode=0；
tobeExplored.push（nodesList.get（startnode））；
System.out.println（“添加到堆栈==>”+nodesList.get（startnode））；
而（！tobeExplored.isEmpty（））
{
List nextVertex=tobeExplored.peek（）；；
vertexVisitCheck.add（nextVertex）；
迭代器迭代器=nextVertex.Iterator（）；
int counter=nextVertex.size（）；
while（iterator.hasNext（））{
int check=iterator.next（）；
如果（！vertexVisitCheck.contains（nodesList.get（check）））
{
tobeExplored.push（nodesList.get（check））；
System.out.println（“添加到堆栈==>”+nodesList.get（检查））；
if（tobeExplored.peek（）.size（）=0）
{
add（nodesList.get（check））；
tobeExplored.pop（）；
}
打破
}
如果（--计数器==0）
{
add（nodesList.get（check））；
tobeExplored.pop（）；
}       
}
}
}

}