Add doubly, circular Linked List, and kruskal graphs (#72)

* Code for inserting elements in doubly linked list

* Circular linked list added

* Graphs Section added

* README updated

graphs/README.md

@@ -0,0 +1,7 @@
+# Graphs
+
+### C or C++
+
+1. [Kruskal Algorithm](c-or-cpp/kruskal-algorithm.cpp)
+
+

graphs/c-or-cpp/kruskal-algorithm.cpp

@@ -0,0 +1,173 @@
+//Graph Kruskal algorithm
+#include <bits/stdc++.h>
+using namespace std;
+
+class Edge {
+public:
+	int src, dest, weight;
+};
+
+class Graph {
+public:
+
+	int V, E;
+	Edge* edge;
+};
+
+// Creates a graph with V vertices and E edges
+Graph* createGraph(int V, int E)
+{
+	Graph* graph = new Graph;
+	graph->V = V;
+	graph->E = E;
+
+	graph->edge = new Edge[E];
+
+	return graph;
+}
+
+// A structure to represent a subset for union-find
+class subset {
+public:
+	int parent;
+	int rank;
+};
+
+
+int find(subset subsets[], int i)
+{
+	// find root and make root as parent of i
+	// (path compression)
+	if (subsets[i].parent != i)
+		subsets[i].parent
+			= find(subsets, subsets[i].parent);
+
+	return subsets[i].parent;
+}
+
+// A function that does union of two sets of x and y
+// (uses union by rank)
+void Union(subset subsets[], int x, int y)
+{
+	int xroot = find(subsets, x);
+	int yroot = find(subsets, y);
+
+	// Attach smaller rank tree under root of high
+	// rank tree (Union by Rank)
+	if (subsets[xroot].rank < subsets[yroot].rank)
+		subsets[xroot].parent = yroot;
+	else if (subsets[xroot].rank > subsets[yroot].rank)
+		subsets[yroot].parent = xroot;
+
+	// If ranks are same, then make one as root and
+	// increment its rank by one
+	else {
+		subsets[yroot].parent = xroot;
+		subsets[xroot].rank++;
+	}
+}
+
+// Compare two edges according to their weights.
+// Used in qsort() for sorting an array of edges
+int myComp(const void* a, const void* b)
+{
+	Edge* a1 = (Edge*)a;
+	Edge* b1 = (Edge*)b;
+	return a1->weight > b1->weight;
+}
+
+// The main function to construct MST using Kruskal's
+// algorithm
+void KruskalMST(Graph* graph)
+{
+	int V = graph->V;
+	Edge result[V]; // Tnis will store the resultant MST
+	int e = 0; // An index variable, used for result[]
+	int i = 0;
+
+
+	qsort(graph->edge, graph->E, sizeof(graph->edge[0]),
+		myComp);
+
+	// Allocate memory for creating V ssubsets
+	subset* subsets = new subset[(V * sizeof(subset))];
+
+	// Create V subsets with single elements
+	for (int v = 0; v < V; ++v)
+	{
+		subsets[v].parent = v;
+		subsets[v].rank = 0;
+	}
+
+	while (e < V - 1 && i < graph->E)
+	{
+
+		Edge next_edge = graph->edge[i++];
+
+		int x = find(subsets, next_edge.src);
+		int y = find(subsets, next_edge.dest);
+
+
+		if (x != y) {
+			result[e++] = next_edge;
+			Union(subsets, x, y);
+		}
+		// Else discard the next_edge
+	}
+
+
+	cout << "Following are the edges in the  "
+			"MST\n";
+	int minimumCost = 0;
+	for (i = 0; i < e; ++i)
+	{
+		cout << result[i].src << " -- " << result[i].dest
+			<< " == " << result[i].weight << endl;
+		minimumCost = minimumCost + result[i].weight;
+	}
+	cout << "Minimum Cost Spanning Tree: " << minimumCost
+		<< endl;
+}
+
+// Driver code
+int main()
+{
+
+
+	int V = 4; // Number of vertices in graph
+	int E = 5; // Number of edges in graph
+	Graph* graph = createGraph(V, E);
+
+	// add edge 0-1
+	graph->edge[0].src = 0;
+	graph->edge[0].dest = 1;
+	graph->edge[0].weight = 10;
+
+	// add edge 0-2
+	graph->edge[1].src = 0;
+	graph->edge[1].dest = 2;
+	graph->edge[1].weight = 6;
+
+	// add edge 0-3
+	graph->edge[2].src = 0;
+	graph->edge[2].dest = 3;
+	graph->edge[2].weight = 5;
+
+	// add edge 1-3
+	graph->edge[3].src = 1;
+	graph->edge[3].dest = 3;
+	graph->edge[3].weight = 15;
+
+	// add edge 2-3
+	graph->edge[4].src = 2;
+	graph->edge[4].dest = 3;
+	graph->edge[4].weight = 4;
+
+
+
+	KruskalMST(graph);
+
+	return 0;
+}
+
+

linked-lists/README.md

@@ -9,6 +9,10 @@
 
 3. [Circular Linked List](c-or-cpp/circular.cpp)
 
+2. [Doubly Linked List](c-or-cpp/doubly.cpp)
+
+3. [Circular Linked List](c-or-cpp/circular.cpp)
+
 ### Java
 
 1. [Singly Linked List](java/singly.cpp)