com.salesforce.jgrapht.alg.EulerianCircuit Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of AptSpringProcessor Show documentation
This project contains the apt processor that implements all the checks enumerated in @Verify. It is a self contained, and shaded jar.
There is a newer version: 2.0.7
Show newest version
/*
 * (C) Copyright 2008-2017, by Andrew Newell and Contributors.
 *
 * JGraphT : a free Java graph-theory library
 *
 * This program and the accompanying materials are dual-licensed under
 * either
 *
 * (a) the terms of the GNU Lesser General Public License version 2.1
 * as published by the Free Software Foundation, or (at your option) any
 * later version.
 *
 * or (per the licensee's choosing)
 *
 * (b) the terms of the Eclipse Public License v1.0 as published by
 * the Eclipse Foundation.
 */
package com.salesforce.jgrapht.alg;

import java.util.*;

import com.salesforce.jgrapht.*;
import com.salesforce.jgrapht.alg.cycle.*;
import com.salesforce.jgrapht.graph.*;

/**
 * This algorithm will check whether a graph is Eulerian (hence it contains an
 * Eulerian circuit). Also, if a
 * graph is Eulerian, the caller can obtain a list of vertices making up the Eulerian circuit. An
 * Eulerian circuit is a circuit which traverses each edge exactly once.
 *
 * @author Andrew Newell
 * @since Dec 21, 2008
 * @deprecated use {@link HierholzerEulerianCycle} instead
 */
@Deprecated
public abstract class EulerianCircuit
{

    /**
     * Test whether a graph is Eulerian. An undirected graph is Eulerian if it is connected and each
     * vertex has an even degree.
     *
     * @param graph the input graph
     * @param  the graph vertex type
     * @param  the graph edge type
     *
     * @return true if the graph is Eulerian, false otherwise
     */
    public static  boolean isEulerian(UndirectedGraph graph)
    {
        return new HierholzerEulerianCycle().isEulerian(graph);
    }

    /**
     * This method will return a list of vertices which represents the Eulerian circuit of the
     * graph.
     *
     * @param g The graph to find an Eulerian circuit
     * @param  the graph vertex type
     * @param  the graph edge type
     *
     * @return null if no Eulerian circuit exists, or a list of vertices representing the Eulerian
     *         circuit if one does exist
     */
    public static  List getEulerianCircuitVertices(UndirectedGraph g)
    {
        // If the graph is not Eulerian then just return a null since no
        // Eulerian circuit exists
        if (!isEulerian(g)) {
            return null;
        }

        // The circuit will be represented by a linked list
        List path = new LinkedList<>();
        UndirectedGraph sg = new UndirectedSubgraph<>(g, null, null);
        path.add(sg.vertexSet().iterator().next());

        // Algorithm for finding an Eulerian circuit Basically this will find an
        // arbitrary circuit, then it will find another arbitrary circuit until
        // every edge has been traversed
        while (sg.edgeSet().size() > 0) {
            V v = null;

            // Find a vertex which has an edge that hasn't been traversed yet,
            // and keep its index position in the circuit list
            int index = 0;
            for (Iterator iter = path.iterator(); iter.hasNext(); index++) {
                v = iter.next();
                if (sg.degreeOf(v) > 0) {
                    break;
                }
            }

            // Finds an arbitrary circuit of the current vertex and
            // appends this into the circuit list
            while (sg.degreeOf(v) > 0) {
                for (V temp : sg.vertexSet()) {
                    if (sg.containsEdge(v, temp)) {
                        path.add(index, temp);
                        sg.removeEdge(v, temp);
                        v = temp;
                        break;
                    }
                }
            }
        }
        return path;
    }
}

// End EulerianCircuit.java