哈密顿路径的时间复杂性

下面是使用回溯来查找图中是否存在哈密尔顿路径的代码 . 根据下面的代码，时间复杂度为 O(V^2) ，其中 V 是顶点的总数 . 但哈密顿量问题是NP完全的 . 根据我的理解，这是一个在多项式时间 n^k 中无法解决的问题，其中输入 n 且 k 是常量 . 我已经测试了下面的代码并且工作正常 . 那我算错时间复杂度了吗？

public boolean check() {

    Stack<Node> nodeStack = new Stack<>();
    nodeStack.add(root);
    root.setIsOnStack();

    while (!nodeStack.isEmpty()) {  

        Node currentNode = nodeStack.peek();   
        for (Entry<Node, Boolean> entry : currentNode.getNeighbourList().entrySet()) { 
            Node currentNeighbourer = entry.getKey();
            if (!currentNeighbourer.isOnStack()) { 
                if (!entry.getValue()) {  
                    nodeStack.push(currentNeighbourer); 
                    currentNeighbourer.setIsOnStack();
                    break;
                }
            } else if (currentNeighbourer == root && nodeStack.size() == noOfVertices) {  
                return true;
            }
        }
        if (currentNode == nodeStack.peek()) {
            for (Entry<Node, Boolean> entry : currentNode.getNeighbourList().entrySet()) { 
                currentNode.setNodeIsNotVisited(entry.getKey()); 
            }
            nodeStack.pop();
            currentNode.setIsNotOnStack();
            Node nodeOnTop = nodeStack.peek();
            nodeOnTop.setNodeIsVisited(currentNode);
        }
    }
    return false;
}

节点类：

public class Node {

private final char label;
private Map<Node, Boolean> neighbourList;
private boolean isOnStack;

public Node(char label) {
    this.label = label;
    this.isOnStack = false;
    neighbourList = new LinkedHashMap<>();
}

public char getLabel() {
    return label;
}

public void addNeighbour(Node node) {
    neighbourList.put(node, false);
}

public boolean isOnStack() {
    return isOnStack;
}

public void setIsOnStack() {
    isOnStack = true;
}

public void setIsNotOnStack() {
    isOnStack = false;
}

public Map<Node, Boolean> getNeighbourList() {
    return neighbourList;
}

public void setNodeIsVisited(Node node) {
    neighbourList.replace(node, true);        
}

public void setNodeIsNotVisited(Node node) {
    neighbourList.replace(node, false);        
}

public boolean isNodeVisited(Node node) {
    return neighbourList.get(node);
}

}