图的应用：哈密尔顿路径

      public List<Integer> getHamiltonianPath(int v) {
        // A path starts from v. (i, next[i]) represents an edge in 
        // the path. isVisited[i] tracks whether i is currently in the 
        // path.
        int[] next = new int[getSize()];       
        for (int i = 0; i < next.length; i++)
          next[i] = -1; // Indicate no subpath from i is found yet
        
        boolean[] isVisited = new boolean[getSize()]; 
        
        // The vertices in the Hamiltionian path are stored in result
        List<Integer> result = null;

        // To speed up search, reorder the adjacency list for each 
        // vertex so that the vertices in the list are in increasing 
        // order of their degrees
        for (int i = 0; i < getSize(); i++)
          reorderNeigborsBasedOnDegree(neighbors.get(i));
        
        if (getHamiltonianPath(v, next, isVisited)) {
          result = new ArrayList<Integer>(); // Create a list for path        
          int vertex = v; // Starting from v
          while (vertex != -1) {
            result.add(vertex); // Add vertex to the result list
            vertex = next[vertex]; // Get the next vertex in the path
          }
        }
        
        return result; // return null if no Hamiltionian path is found
      }

      /** Reorder the adjacency list in increasing order of degrees */
      private void reorderNeigborsBasedOnDegree(List<Integer> list) {
        for (int i = list.size() - 1; i >= 1; i--) {
          // Find the maximum in the list[0..i]
          int currentMaxDegree = getDegree(list.get(0));
          int currentMaxIndex = 0;

          for (int j = 1; j <= i; j++) {
            if (currentMaxDegree < getDegree(list.get(j))) { 
              currentMaxDegree = getDegree(list.get(j));
              currentMaxIndex = j;
            }
          }

          // Swap list[i] with list[currentMaxIndex] if necessary;
          if (currentMaxIndex != i) {
            int temp = list.get(currentMaxIndex);
            list.set(currentMaxIndex, list.get(i));
            list.set(i, temp);
          }
        }
      }
      
      /** Return true if all elements in array isVisited are true */
      private boolean allVisited(boolean[] isVisited) {
        boolean result = true;
        
        for (int i = 0; i < getSize(); i++) 
          result = result && isVisited[i];
        
        return result;
      }
      
      /** Search for a Hamiltonian path from v */
      private boolean getHamiltonianPath(int v, int[] next,
          boolean[] isVisited) {
        isVisited[v] = true; // Mark vertex v visited

        if (allVisited(isVisited)) 
          return true; // The path now includes all vertices, thus found
          
        for (int i = 0; i < neighbors.get(v).size(); i++) {
          int u = neighbors.get(v).get(i);
          if (!isVisited[u] && 
              getHamiltonianPath(u, next, isVisited)) {
            next[v] = u; // Edge (v, u) is in the path
            return true; 
          }
        }

        isVisited[v] = false; // Backtrack, v is marked unvisited now
        return false; // No Hamiltonian path exists from vertex v
      }

 对于一个给定的网络，确定起点后，如果存在一条路径，最后又回到原出发点,且满足每个顶点只被访问一次的情况下能穿过这个网络，我们就说这个网络存在哈密顿路径。