Repository: TheAlgorithms/Java
File: src/main/java/com/thealgorithms/datastructures/graphs/WelshPowell.java (Java)

Code before:
            boolean[] usedColors = computeUsedColors(graph, vertex, colors, numVer); // Use helper method to compute used colors
            colors[vertex] = firstUnusedColor(usedColors, numVer); // Use helper method to find first unused color
        }

        return colors;
    }

    private static int[] initializeColors(int numVer) {
        int[] colors = new int[numVer];
        Arrays.fill(colors, -1);
        return colors;
    }

    private static Integer[] getSortedNodes(WPGraph graph, int numVer) {
        return IntStream.range(0, numVer).boxed().sorted(Comparator.comparingInt(v -> - graph.getAdjList(v).size())).toArray(Integer[] ::new);
    }

    private static boolean[] computeUsedColors(WPGraph graph, int vertex, int[] colors, int numVer) {
        boolean[] usedColors = new boolean[numVer];
        graph.getAdjList(vertex).stream().map(neighbor -> colors[neighbor]).filter(color -> color != -1).forEach(color -> usedColors[color] = true);
        return usedColors;
    }

    private static int firstUnusedColor(boolean[] usedColors, int numVer) {
        return IntStream.range(0, numVer).filter(color -> !usedColors[color]).findFirst().getAsInt();
    }

    // Public static methods for testing purpose
    public static WPGraph createGraph(int vertices) {
        return new WPGraph(vertices);
    }

    public static void addEdge(WPGraph graph, int nodeA, int nodeB) {
        graph.addEdge(nodeA, nodeB);
    }
}


Review comment (suggestion):
```suggestion
    private static int firstUnusedColor(boolean[] usedColors) {
        return IntStream.range(0, usedColors.length).filter(color -> !usedColors[color]).findFirst().getAsInt();
    }
```

Code after:

        int getNumVertices() {
            return adjacencyLists.length;
        }
    }

    public static Graph makeGraph(int numberOfVertices, int[][] listOfEdges) {
        Graph graph = new Graph(numberOfVertices);
        for (int[] edge : listOfEdges) {
            if (edge.length != 2) {
                throw new IllegalArgumentException("Edge array must have exactly two elements");
            }
            graph.addEdge(edge[0], edge[1]);
        }
        return graph;
    }

    public static int[] findColoring(Graph graph) {
        int[] colors = initializeColors(graph.getNumVertices());
        Integer[] sortedVertices = getSortedNodes(graph);
        for (int vertex : sortedVertices) {
            if (isBlank(colors[vertex])) {
                boolean[] usedColors = computeUsedColors(graph, vertex, colors);
                final var newColor = firstUnusedColor(usedColors);
                colors[vertex] = newColor;
                Arrays.stream(sortedVertices).forEach(otherVertex -> {
                    if (isBlank(colors[otherVertex]) && !isAdjacentToColored(graph, otherVertex, colors)) {
                        colors[otherVertex] = newColor;
                    }
                });
            }
        }
        return colors;
    }

    private static boolean isBlank(int color) {
        return color == BLANK_COLOR;
    }

    private static boolean isAdjacentToColored(Graph graph, int vertex, int[] colors) {
        return graph.getAdjacencyList(vertex).stream().anyMatch(otherVertex -> !isBlank(colors[otherVertex]));
    }

    private static int[] initializeColors(int numberOfVertices) {
        int[] colors = new int[numberOfVertices];
        Arrays.fill(colors, BLANK_COLOR);
        return colors;
    }

    private static Integer[] getSortedNodes(final Graph graph) {
        return IntStream.range(0, graph.getNumVertices()).boxed().sorted(Comparator.comparingInt(v -> - graph.getAdjacencyList(v).size())).toArray(Integer[] ::new);