Add graph references

references/programiz/adj_list.c

@@ -0,0 +1,78 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+// Adjascency List representation in C
+
+#include <stdio.h>
+#include <stdlib.h>
+
+struct node {
+  int vertex;
+  struct node* next;
+};
+struct node* createNode(int);
+
+struct Graph {
+  int numVertices;
+  struct node** adjLists;
+};
+
+// Create a node
+struct node* createNode(int v) {
+  struct node* newNode = malloc(sizeof(struct node));
+  newNode->vertex = v;
+  newNode->next = NULL;
+  return newNode;
+}
+
+// Create a graph
+struct Graph* createAGraph(int vertices) {
+  struct Graph* graph = malloc(sizeof(struct Graph));
+  graph->numVertices = vertices;
+
+  graph->adjLists = malloc(vertices * sizeof(struct node*));
+
+  int i;
+  for (i = 0; i < vertices; i++)
+    graph->adjLists[i] = NULL;
+
+  return graph;
+}
+
+// Add edge
+void addEdge(struct Graph* graph, int s, int d) {
+  // Add edge from s to d
+  struct node* newNode = createNode(d);
+  newNode->next = graph->adjLists[s];
+  graph->adjLists[s] = newNode;
+
+  // Add edge from d to s
+  newNode = createNode(s);
+  newNode->next = graph->adjLists[d];
+  graph->adjLists[d] = newNode;
+}
+
+// Print the graph
+void printGraph(struct Graph* graph) {
+  int v;
+  for (v = 0; v < graph->numVertices; v++) {
+    struct node* temp = graph->adjLists[v];
+    printf("\n Vertex %d\n: ", v);
+    while (temp) {
+      printf("%d -> ", temp->vertex);
+      temp = temp->next;
+    }
+    printf("\n");
+  }
+}
+
+int main() {
+  struct Graph* graph = createAGraph(4);
+  addEdge(graph, 0, 1);
+  addEdge(graph, 0, 2);
+  addEdge(graph, 0, 3);
+  addEdge(graph, 1, 2);
+
+  printGraph(graph);
+
+  return 0;
+}

references/programiz/adj_list.cpp

@@ -0,0 +1,39 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+// Adjascency List representation in C++
+
+#include <vector>
+#include <iostream>
+
+using namespace std;
+
+// Add edge
+void addEdge(vector<int> adj[], int s, int d) {
+  adj[s].push_back(d);
+  adj[d].push_back(s);
+}
+
+// Print the graph
+void printGraph(vector<int> adj[], int V) {
+  for (int d = 0; d < V; ++d) {
+    cout << "\n Vertex "
+       << d << ":";
+    for (auto x : adj[d])
+      cout << "-> " << x;
+    printf("\n");
+  }
+}
+
+int main() {
+  int V = 5;
+
+  // Create a graph
+  vector<int> adj[V];
+
+  // Add edges
+  addEdge(adj, 0, 1);
+  addEdge(adj, 0, 2);
+  addEdge(adj, 0, 3);
+  addEdge(adj, 1, 2);
+  printGraph(adj, V);
+}

references/programiz/adj_list.py

@@ -0,0 +1,46 @@
+# Adjascency List representation in Python
+
+
+class AdjNode:
+    def __init__(self, value):
+        self.vertex = value
+        self.next = None
+
+
+class Graph:
+    def __init__(self, num):
+        self.V = num
+        self.graph = [None] * self.V
+
+    # Add edges
+    def add_edge(self, s, d):
+        node = AdjNode(d)
+        node.next = self.graph[s]
+        self.graph[s] = node
+
+        node = AdjNode(s)
+        node.next = self.graph[d]
+        self.graph[d] = node
+
+    # Print the graph
+    def print_agraph(self):
+        for i in range(self.V):
+            print("Vertex " + str(i) + ":", end="")
+            temp = self.graph[i]
+            while temp:
+                print(" -> {}".format(temp.vertex), end="")
+                temp = temp.next
+            print(" \n")
+
+
+if __name__ == "__main__":
+    V = 5
+
+    # Create graph and edges
+    graph = Graph(V)
+    graph.add_edge(0, 1)
+    graph.add_edge(0, 2)
+    graph.add_edge(0, 3)
+    graph.add_edge(1, 2)
+
+    graph.print_agraph()

references/programiz/adj_mat.c

@@ -0,0 +1,48 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+// Adjacency Matrix representation in C
+
+#include <stdio.h>
+#define V 4
+
+// Initialize the matrix to zero
+void init(int arr[][V]) {
+  int i, j;
+  for (i = 0; i < V; i++)
+    for (j = 0; j < V; j++)
+      arr[i][j] = 0;
+}
+
+// Add edges
+void addEdge(int arr[][V], int i, int j) {
+  arr[i][j] = 1;
+  arr[j][i] = 1;
+}
+
+// Print the matrix
+void printAdjMatrix(int arr[][V]) {
+  int i, j;
+
+  for (i = 0; i < V; i++) {
+    printf("%d: ", i);
+    for (j = 0; j < V; j++) {
+      printf("%d ", arr[i][j]);
+    }
+    printf("\n");
+  }
+}
+
+int main() {
+  int adjMatrix[V][V];
+
+  init(adjMatrix);
+  addEdge(adjMatrix, 0, 1);
+  addEdge(adjMatrix, 0, 2);
+  addEdge(adjMatrix, 1, 2);
+  addEdge(adjMatrix, 2, 0);
+  addEdge(adjMatrix, 2, 3);
+
+  printAdjMatrix(adjMatrix);
+
+  return 0;
+}

references/programiz/adj_mat.cpp

@@ -0,0 +1,64 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+// Adjacency Matrix representation in C++
+
+#include <iostream>
+using namespace std;
+
+class Graph {
+   private:
+  bool** adjMatrix;
+  int numVertices;
+
+   public:
+  // Initialize the matrix to zero
+  Graph(int numVertices) {
+    this->numVertices = numVertices;
+    adjMatrix = new bool*[numVertices];
+    for (int i = 0; i < numVertices; i++) {
+      adjMatrix[i] = new bool[numVertices];
+      for (int j = 0; j < numVertices; j++)
+        adjMatrix[i][j] = false;
+    }
+  }
+
+  // Add edges
+  void addEdge(int i, int j) {
+    adjMatrix[i][j] = true;
+    adjMatrix[j][i] = true;
+  }
+
+  // Remove edges
+  void removeEdge(int i, int j) {
+    adjMatrix[i][j] = false;
+    adjMatrix[j][i] = false;
+  }
+
+  // Print the martix
+  void toString() {
+    for (int i = 0; i < numVertices; i++) {
+      cout << i << " : ";
+      for (int j = 0; j < numVertices; j++)
+        cout << adjMatrix[i][j] << " ";
+      cout << "\n";
+    }
+  }
+
+  ~Graph() {
+    for (int i = 0; i < numVertices; i++)
+      delete[] adjMatrix[i];
+    delete[] adjMatrix;
+  }
+};
+
+int main() {
+  Graph g(4);
+
+  g.addEdge(0, 1);
+  g.addEdge(0, 2);
+  g.addEdge(1, 2);
+  g.addEdge(2, 0);
+  g.addEdge(2, 3);
+
+  g.toString();
+}

references/programiz/adj_mat.py

@@ -0,0 +1,51 @@
+# Adjacency Matrix representation in Python
+
+
+class Graph(object):
+
+    # Initialize the matrix
+    def __init__(self, size):
+        self.adjMatrix = []
+        for _ in range(size):
+            self.adjMatrix.append([0 for _ in range(size)])
+        self.size = size
+
+    # Add edges
+    def add_edge(self, v1, v2):
+        if v1 == v2:
+            print("Same vertex %d and %d" % (v1, v2))
+        self.adjMatrix[v1][v2] = 1
+        self.adjMatrix[v2][v1] = 1
+
+    # Remove edges
+    def remove_edge(self, v1, v2):
+        if self.adjMatrix[v1][v2] == 0:
+            print("No edge between %d and %d" % (v1, v2))
+            return
+        self.adjMatrix[v1][v2] = 0
+        self.adjMatrix[v2][v1] = 0
+
+    def __len__(self):
+        return self.size
+
+    # Print the matrix
+    def print_matrix(self):
+        for row in self.adjMatrix:
+            for val in row:
+                print('{:4}'.format(val)),
+            print
+
+
+def main():
+    g = Graph(5)
+    g.add_edge(0, 1)
+    g.add_edge(0, 2)
+    g.add_edge(1, 2)
+    g.add_edge(2, 0)
+    g.add_edge(2, 3)
+
+    g.print_matrix()
+
+
+if __name__ == '__main__':
+    main()