dist-javascript-algorithms-and-data-structures/dist/algorithms/graph/kruskal/kruskal.js

Algorithms and data-structures implemented on JavaScript

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = kruskal;

var _Graph = _interopRequireDefault(require("../../../data-structures/graph/Graph"));

var _QuickSort = _interopRequireDefault(require("../../sorting/quick-sort/QuickSort"));

var _DisjointSet = _interopRequireDefault(require("../../../data-structures/disjoint-set/DisjointSet"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * @param {Graph} graph
 * @return {Graph}
 */
function kruskal(graph) {
  // It should fire error if graph is directed since the algorithm works only
  // for undirected graphs.
  if (graph.isDirected) {
    throw new Error('Kruskal\'s algorithms works only for undirected graphs');
  } // Init new graph that will contain minimum spanning tree of original graph.


  const minimumSpanningTree = new _Graph.default(); // Sort all graph edges in increasing order.

  const sortingCallbacks = {
    /**
     * @param {GraphEdge} graphEdgeA
     * @param {GraphEdge} graphEdgeB
     */
    compareCallback: (graphEdgeA, graphEdgeB) => {
      if (graphEdgeA.weight === graphEdgeB.weight) {
        return 1;
      }

      return graphEdgeA.weight <= graphEdgeB.weight ? -1 : 1;
    }
  };
  const sortedEdges = new _QuickSort.default(sortingCallbacks).sort(graph.getAllEdges()); // Create disjoint sets for all graph vertices.

  const keyCallback = graphVertex => graphVertex.getKey();

  const disjointSet = new _DisjointSet.default(keyCallback);
  graph.getAllVertices().forEach(graphVertex => {
    disjointSet.makeSet(graphVertex);
  }); // Go through all edges started from the minimum one and try to add them
  // to minimum spanning tree. The criteria of adding the edge would be whether
  // it is forms the cycle or not (if it connects two vertices from one disjoint
  // set or not).

  for (let edgeIndex = 0; edgeIndex < sortedEdges.length; edgeIndex += 1) {
    /** @var {GraphEdge} currentEdge */
    const currentEdge = sortedEdges[edgeIndex]; // Check if edge forms the cycle. If it does then skip it.

    if (!disjointSet.inSameSet(currentEdge.startVertex, currentEdge.endVertex)) {
      // Unite two subsets into one.
      disjointSet.union(currentEdge.startVertex, currentEdge.endVertex); // Add this edge to spanning tree.

      minimumSpanningTree.addEdge(currentEdge);
    }
  }

  return minimumSpanningTree;
}