IronCodeMan

Graphs

A graph is a non-linear data structure in programming that consists of nodes (vertices) connected by edges. Graphs are used to represent relationships between entities, where nodes represent entities and edges represent connections or relationships between them. Graphs are commonly used in programming for tasks such as modeling networks, representing social relationships, solving pathfinding problems, and analyzing data structures. For example, in a social network application, a graph could be used to represent users as nodes and friendships as edges, enabling efficient operations such as finding mutual friends or recommending new connections. Additionally, graphs are used in geographical information systems (GIS) to represent road networks, where nodes represent intersections and edges represent roads connecting them.

Examples

C

// No Native Support or Implementation

C#

using System;
using System.Collections.Generic;

public class Graph {
  Dictionary<string, List<string>> graphMap =
  new Dictionary<string, List<string>>();
  
  public void addNode(string val) {
    List<string> tempList = new List<string>();
    graphMap.Add(val, tempList);
  }
  
 public void addVertices(
   string node1, string node2
 ) {
    List<string> tempArr = new List<string>();
    
    if(graphMap.ContainsKey(node1) == false) {
      graphMap.Add(node1, tempArr);
    }
    if(graphMap.ContainsKey(node2) == false) {
      graphMap.Add(node2, tempArr);
    }

    graphMap[node1].Add(node2);
    graphMap[node2].Add(node1);
  }

  public void breadthTraverse(string start) {
    Queue<string> queue = new Queue<string>();
    queue.Enqueue(start);
    
    Dictionary<string, bool> visited = 
      new Dictionary<string, bool>();
      
    visited.Add(start, true);
    
    while(queue.Count > 0) {
      string val = queue.Dequeue();
      Console.WriteLine(val + "\n");

      List<string> tempArr = graphMap[val];

      for (int i = 0; i < tempArr.Count; i++) {
        string tempKey = tempArr[i];
        if(
          visited.ContainsKey(tempKey) == false
        ) {
           queue.Enqueue(tempKey);
           visited.Add(tempKey, true);
        }
      }
    }
  }

  public void depthTraverse(string start) {
    Stack<string> stack = new Stack<string>();
    stack.Push(start);

    Dictionary<string, bool> visited = 
      new Dictionary<string, bool>();
      
    visited.Add(start, true);
    
    while(stack.Count > 0) {
      string val = stack.Pop();
      Console.WriteLine(val + "\n");

      List<string> tempArr = graphMap[val];

      for (int i = 0; i < tempArr.Count; i++) {
        string tempKey = tempArr[i];
        if(
          visited.ContainsKey(tempKey) == false
        ) {
          stack.Push(tempKey);
          visited.Add(tempKey, true);
        }
      }
    }
  }
 
  public static void Main(string[] args) {
    Graph newGraph = new Graph();
    newGraph.addNode("a");
    newGraph.addVertices("a", "b");
    newGraph.addVertices("a", "c");
    newGraph.addVertices("b", "d");
    newGraph.addVertices("b", "e");
    newGraph.addVertices("d", "f");
    newGraph.addVertices("d", "g");
    newGraph.addVertices("d", "h");
    newGraph.addVertices("e", "i");
    newGraph.addVertices("e", "j");
    newGraph.breadthTraverse("a");
    newGraph.depthTraverse("a");
  }
}

C++

#include <iostream>
#include <queue>
#include <stack>
#include <map>
#include <vector>
using namespace std;

class Graph {
  public:
    map<string, vector<string>> graphMap;

    void addNode(string val) {
      graphMap[val] = {};
    }

    void addVertices(string node1, string node2) {
      if(graphMap.find(node1) == graphMap.end()) {
        graphMap[node1] = {};
      }
      if(graphMap.find(node2) == graphMap.end()) {
        graphMap[node2] = {};
      }

      graphMap[node1].push_back(node2);
      graphMap[node2].push_back(node1);
    }

    void breadthTraverse (string start) {
      queue<string> newQueue;
      newQueue.push(start);
      
      map<string, bool> visited;
      visited[start] = true;

      while(newQueue.size() > 0) {
        string val = newQueue.front();
        cout << val << endl;
        newQueue.pop();
        vector<string> tempArr = graphMap[val];

        for (int i = 0; i < tempArr.size(); i++) {
          if (!visited[tempArr[i]]) {
            newQueue.push(tempArr[i]);
            visited[tempArr[i]] = true;
          }
        }
      }
    }

    void depthTraverse (string start) {
      stack<string> newStack;
      newStack.push(start);

      map<string, bool> visited;
      visited[start] = true;

      while(newStack.size() > 0) {
        string val = newStack.top();
        cout << val << endl;
        newStack.pop();
        vector<string> tempArr = graphMap[val];

        for (int i = 0; i < tempArr.size(); i++) {
          if (!visited[tempArr[i]]) {
            newStack.push(tempArr[i]);
            visited[tempArr[i]] = true;
          }
        }
      }
    }
};

int main() {
  Graph newGraph;
  newGraph.addNode("a");
  newGraph.addVertices("a", "b");
  newGraph.addVertices("a", "c");
  newGraph.addVertices("b", "d");
  newGraph.addVertices("b", "e");
  newGraph.addVertices("d", "f");
  newGraph.addVertices("d", "g");
  newGraph.addVertices("d", "h");
  newGraph.addVertices("e", "i");
  newGraph.addVertices("e", "j");
  newGraph.breadthTraverse("a");
  newGraph.depthTraverse("a");
  return 0;
}

Go

import "fmt"

type Graph struct {
  graphMap map[string][]string
}

func (graph *Graph) addNode(value string) {
  if (graph.graphMap == nil) {
    // create new hashmap
    graph.graphMap = make(map[string][]string)
  }
  graph.graphMap[value] = []string{}
}

func (graph *Graph) addVertices(
  node1 string, 
  node2 string ) {
  _, n1exists := graph.graphMap[node1] 
  if n1exists == false {
    graph.graphMap[node1] = []string{}
  }
  _, n2exists := graph.graphMap[node1] 
  if n2exists == false{
    graph.graphMap[node2] = []string{}
  }
  graph.graphMap[node1] = 
    append(graph.graphMap[node1], node2)
  graph.graphMap[node2] =
    append(graph.graphMap[node2], node1)
}

func (graph *Graph) breadthTraverse(start string) {
  queue := []string{start}
  visited := map[string]bool{}
  visited[start] = true
  
  for len(queue) > 0 {
    val := queue[0]
    fmt.Println(val)
    queue = queue[1:]
    var tempArr = graph.graphMap[val]
    for i := 0; i < len(tempArr); i++ {
      _, exists := visited[tempArr[i]]
      if exists == false {
        queue = append(queue, tempArr[i])
        visited[tempArr[i]] = true
      }
    }
  }
}

func (graph *Graph) depthTraverse(start string) {
  stack := []string{start}
  visited := map[string]bool{}
  visited[start] = true
  
  for len(stack) > 0 {
    val := stack[len(stack) - 1]
    fmt.Println(val)
    stack = stack[:len(stack) - 1]
    var tempArr = graph.graphMap[val]
    for i := 0; i < len(tempArr); i++ {
      _, exists := visited[tempArr[i]]
      if exists == false {
        stack = append(stack, tempArr[i])
        visited[tempArr[i]] = true
      }
    }
  }
}

newGraph := Graph{}
newGraph.addNode("a");
newGraph.addVertices("a", "b");
newGraph.addVertices("a", "c");
newGraph.addVertices("b", "d");
newGraph.addVertices("b", "e");
newGraph.addVertices("d", "f");
newGraph.addVertices("d", "g");
newGraph.addVertices("d", "h");
newGraph.addVertices("e", "i");
newGraph.addVertices("e", "j");
newGraph.breadthTraverse("a");
newGraph.depthTraverse("a");

Java

import java.util.*; 

class Graph {
  public Map<String, ArrayList<String>>
    graphMap = new HashMap<>();
  
  public void addNode(String val) {
    ArrayList<String> tempArr = 
      new ArrayList<>();

    graphMap.put(val, tempArr);
  }
  
  public void addVertices(
    String node1, String node2
  ) {
    ArrayList<String> tempArr = 
      new ArrayList<String>();
    
    if(graphMap.containsKey(node1) == false) {
      graphMap.put(node1, tempArr);
    }
    if(graphMap.containsKey(node2) == false) {
      graphMap.put(node2, tempArr);
    }

    graphMap.get(node1).add(node2);
    graphMap.get(node2).add(node1);
  }

  public void breadthTraverse(String start) {
    ArrayList<String> queue =
    new ArrayList<String>();

    queue.add(start);
    Map<String, Boolean> visited =
      new HashMap<>();

    visited.put(start, true);
    
    while(queue.size() > 0) {
      String val = queue.get(0);
      System.out.println(val );

      queue.remove(0);
      ArrayList<String> tempArr =
        graphMap.get(val);

      for (int i = 0; i < tempArr.size(); i++) {
        String tempKey = tempArr.get(i);
        if(
          visited.containsKey(tempKey
        ) == false) {
          queue.add(tempKey);
          visited.put(tempKey, true);
        }
      }
    }
  }

  public void depthTraverse(String start) {
    ArrayList<String> stack =
      new ArrayList<>();

    stack.add(start);

    Map<String, Boolean> visited =
      new HashMap<>();

    visited.put(start, true);
    
    while(stack.size() > 0) {
      String val = stack.get(stack.size() - 1);
      System.out.println(val );
      stack.remove(stack.size() - 1);
      ArrayList<String> tempArr =
        graphMap.get(val);

      for (int i = 0; i < tempArr.size(); i++) {
        String tempKey = tempArr.get(i);
        if(
          visited.containsKey(tempKey) == false
        ) {
            stack.add(tempKey);
            visited.put(tempKey, true);
        }
      }
    }
  }

  public static void main(String[] args) {
    Graph newGraph = new Graph();
    newGraph.addNode("a");
    newGraph.addVertices("a", "b");
    newGraph.addVertices("a", "c");
    newGraph.addVertices("b", "d");
    newGraph.addVertices("b", "e");
    newGraph.addVertices("d", "f");
    newGraph.addVertices("d", "g");
    newGraph.addVertices("d", "h");
    newGraph.addVertices("e", "i");
    newGraph.addVertices("e", "j");
    newGraph.breadthTraverse("a");
    newGraph.depthTraverse("a");
  }
}

JavaScript

class Graph {
  constructor() {
    this.graphMap = {};
  }
  
  addNode(val) {
   this.graphMap[val] = [];
  }
  
  addVertices(node1, node2) {
    if(!this.graphMap[node1]) {
      this.graphMap[node1] = [];
    }
    if(!this.graphMap[node2]) {
      this.graphMap[node2] = [];
    }

    this.graphMap[node1].push(node2);
    this.graphMap[node2].push(node1);
  }
  
  breadthTraverse(start) {
    const queue = [start];
    const visited = {};
    visited[start] = true;

    while(queue.length) {
      const val = queue.shift();
      console.log(val);

      const tempArr = this.graphMap[val];

      for (let i = 0; i < tempArr.length; i++) {
        if (!visited[tempArr[i]]) {
          queue.push(tempArr[i]);
          visited[tempArr[i]] = true;
        }
      }
    }
  }

  depthTraverse(start) {
    const stack = [start];
    const visited = {};
    visited[start] = true;

    while(stack.length) {
      const val = stack.pop();
      console.log(val);

      const tempArr = this.graphMap[val];

      for (let i = 0; i < tempArr.length; i++) {
        if (!visited[tempArr[i]]) {
          stack.push(tempArr[i]);
          visited[tempArr[i]] = true;
        }
      }
    }
  }
  
}

const newGraph = new Graph();
newGraph.addNode("a");
newGraph.addVertices("a", "b");
newGraph.addVertices("a", "c");
newGraph.addVertices("b", "d");
newGraph.addVertices("b", "e");
newGraph.addVertices("d", "f");
newGraph.addVertices("d", "g");
newGraph.addVertices("d", "h");
newGraph.addVertices("e", "i");
newGraph.addVertices("e", "j");
newGraph.breadthTraverse("a");
newGraph.depthTraverse("a");

Kotlin

import java.util.Queue;
import java.util.LinkedList;
import java.util.ArrayDeque;

class Graph {
  val graphMap = 
    HashMap<String, MutableList<String>> ();
  
  fun addNode(newVal:String) {
    val tempArr = 
      mutableListOf<String>();

    graphMap.put(newVal, tempArr);
  }
  
  fun addVertices(
    node1:String, node2:String
  ) {
    val tempArr = 
      mutableListOf<String>();
    
    if(graphMap.containsKey(node1) == false) {
      graphMap.put(node1, tempArr);
    }
    if(graphMap.containsKey(node2) == false) {
      graphMap.put(node2, tempArr);
    }

    graphMap[node1]?.add(node2);
    graphMap[node2]?.add(node1);
  }

  fun breadthTraverse(start:String) {
    val queue: Queue<String> = 
      LinkedList<String>();

    queue.add(start);
    val visited =
      HashMap<String, Boolean>();

    visited.put(start, true);
    
    while(queue.count() > 0) {
      var currentVal = queue.peek();
      println(currentVal);
      
      queue.remove();
      val tempArr = graphMap[currentVal];

      for (item in tempArr.orEmpty()) {
        if(
          visited.containsKey(item) == false
        ) {
          queue.add(item);
          visited.put(item, true);
        }
      }
    }
  }

  fun depthTraverse(start:String) {
    val stack =
      ArrayDeque<String>();
    stack.push(start);

    val visited =
      HashMap<String, Boolean>();
    visited.put(start, true);
    
    while(stack.count() > 0) {
      val currentVal = stack.peek();
      println(currentVal);
      stack.pop();
      val tempArr = graphMap[currentVal];
      for (item in tempArr.orEmpty()) {
        if(
          visited.containsKey(item) == false
        ) {
            stack.add(item);
            visited.put(item, true);
        }
      }
    }
  }
}

val newGraph = Graph();
newGraph.addNode("a");
newGraph.addVertices("a", "b");
newGraph.addVertices("a", "c");
newGraph.addVertices("b", "d");
newGraph.addVertices("b", "e");
newGraph.addVertices("d", "f");
newGraph.addVertices("d", "g");
newGraph.addVertices("d", "h");
newGraph.addVertices("e", "i");
newGraph.addVertices("e", "j");
newGraph.breadthTraverse("a");
newGraph.depthTraverse("a");

MatLab

classdef Graph
  properties
    graphMap
  end
    
  methods
    function obj = Graph()
      obj.graphMap = containers.Map();
    end
        
    function addNode(obj, val)
      obj.graphMap(val) = {};
    end
        
    function addVertices(obj, node1, node2)
      if ~isKey(obj.graphMap, node1)
          obj.graphMap(node1) = {};
      end
      if ~isKey(obj.graphMap, node2)
          obj.graphMap(node2) = {};
      end

      obj.graphMap(node1) = [
        obj.graphMap(node1), node2
      ];
      obj.graphMap(node2) = [
        obj.graphMap(node2), node1
      ];
    end
        
    function breadthTraverse(obj, start)
      queue = {start};
      visited = containers.Map(start, true);
      while ~isempty(queue)
        val = queue{1};
        disp(val);

        queue(1) = [];
        tempArr = obj.graphMap(val);
        
        for i = 1:length(tempArr)
          if ~visited.isKey(tempArr{i})
            queue = [queue, tempArr{i}];
            visited(tempArr{i}) = true;
          end
        end
      end
    end

    function depthTraverse(obj, start)
      stack = {start};
      visited = containers.Map(start, true);
      while ~isempty(stack)
        val = stack{end};
        disp(val);
            
        stack(end) = [];
        tempArr = obj.graphMap(val);
            
        for i = 1:length(tempArr)
          if ~visited.isKey(tempArr{i})
            stack = [stack, tempArr{i}];
            visited(tempArr{i}) = true;
          end
        end
      end
    end
  end
end

newGraph = Graph();
newGraph.addNode('a');
newGraph.addVertices('a', 'b');
newGraph.addVertices('a', 'c');
newGraph.addVertices('b', 'd');
newGraph.addVertices('b', 'e');
newGraph.addVertices('d', 'f');
newGraph.addVertices('d', 'g');
newGraph.addVertices('d', 'h');
newGraph.addVertices('e', 'i');
newGraph.addVertices('e', 'j');
newGraph.breadthTraverse('a');
newGraph.depthTraverse('a');

PHP

class Graph {
  public $graphMap = array();

  public function addNode($val) {
    $this->graphMap[$val] = array();
  }
  
  public function addVertices($node1, $node2) {
    if (array_key_exists(
        $node1,
        $this->graphMap) == false) {
      $this->graphMap[$node1] = array();
    }
    if (array_key_exists(
        $node2,
        $this->graphMap) == false) {
      $this->graphMap[$node2] = array();
    }
    
    array_push($this->graphMap[$node1], $node2);
    array_push($this->graphMap[$node2], $node1);
  }
  
  public function breadthTraverse($start) {
    $queue = array($start);
    $visited = array();
    $visited[$start] = true;

    while(count($queue) > 0) {
      $val = array_shift($queue);
      echo $val. "\n";
      
      $tempArr = $this->graphMap[$val];

      for ($i = 0; $i < count($tempArr); $i++) {
        if (array_key_exists(
            $tempArr[$i],
            $visited) == false) {
          array_push($queue, $tempArr[$i]);
          $visited[$tempArr[$i]] = true;
        }
      }
    }
  }
  
  public function depthTraverse($start) {
    $stack = array($start);
    $visited = array();
    $visited[$start] = true;

    while(count($stack) > 0) {
      $val = array_pop($stack);
      echo $val, "\n";
      
      $tempArr = $this->graphMap[$val];

      for ($i = 0; $i < count($tempArr); $i++) {
        if (array_key_exists(
            $tempArr[$i],
            $visited) == false) {
          array_push($stack, $tempArr[$i]);
          $visited[$tempArr[$i]] = true;
        }
      }
    }
  }
}

$newGraph = new Graph();
$newGraph->addNode("a");
$newGraph->addVertices("a", "b");
$newGraph->addVertices("a", "c");
$newGraph->addVertices("b", "d");
$newGraph->addVertices("b", "e");
$newGraph->addVertices("d", "f");
$newGraph->addVertices("d", "g");
$newGraph->addVertices("d", "h");
$newGraph->addVertices("e", "i");
$newGraph->addVertices("e", "j");
$newGraph->breadthTraverse("a");
$newGraph->depthTraverse("a");

Python

class Graph:
  def __init__(self):
    self.graphMap = {}
    
  def addNode(self, val):
    self.graphMap[val] = []
    
  def addVertices(self, node1, node2):
    if node1 not in self.graphMap:
        self.graphMap[node1] = []
    if node2 not in self.graphMap:
        self.graphMap[node2] = []

    self.graphMap[node1].append(node2)
    self.graphMap[node2].append(node1)

  def breadthTraverse(self, start):
    queue = [start]
    visited = {}
    visited[start] = True
    
    while(len(queue) > 0):
      val = queue[0]
      print(val)

      queue.pop(0)
      tempArr = self.graphMap[val]

      for i in tempArr:
        if i not in visited:
          queue.append(i)
          visited[i] = True
         
  def depthTraverse(self, start):
    stack = [start]
    visited = {}
    visited[start] = True
    
    while(len(stack) > 0):
      val = stack[len(stack) - 1]
      print(val)

      stack.pop(len(stack) - 1)
      tempArr = self.graphMap[val]

      for i in tempArr:
        if i not in visited:
          stack.append(i)
          visited[i] = True
          
newGraph = Graph()
newGraph.addNode('a');
newGraph.addVertices('a', 'b');
newGraph.addVertices('a', 'c');
newGraph.addVertices('b', 'd');
newGraph.addVertices('b', 'e');
newGraph.addVertices('d', 'f');
newGraph.addVertices('d', 'g');
newGraph.addVertices('d', 'h');
newGraph.addVertices('e', 'i');
newGraph.addVertices('e', 'j');
newGraph.breadthTraverse("a");
newGraph.depthTraverse("a");

R

rm(list = ls())

Graph <- setRefClass("Graph",
  fields = list(graphMap = "list"),
  methods = list(
    addNode = function(val) {
      graphMap[[val]] <<- list()
    },
    
    addVertices = function (node1, node2) {
      templist <- list()
      if(node1 %in% names(graphMap) == FALSE) {
        graphMap[[node1]] <<- list()
      }
      if(node2 %in% names(graphMap) == FALSE) {
        graphMap[[node2]] <<- list()
      }
      nodeOneArr = graphMap[[node1]]
      nodeTwoArr = graphMap[[node2]]

      graphMap[[node1]] <<- append(
        nodeOneArr,
        node2
      )
      graphMap[[node2]] <<- append(
        nodeTwoArr,
        node1
      )
    },
    
    breadthTraverse = function(start) {
      queue <- list(start)
      visited <- list()
      visited[[start]] <- TRUE
      
      while(length(queue) > 0) {
        curVal = queue[1]
        print(curVal)
        queue <- queue[-1]
        tempArr = graphMap[[sprintf("%s", curVal)]]
        for(tempVal in tempArr) {
          if (tempVal %in% names(visited) == FALSE) {
            queue <- append(queue, tempVal)
            visited[[tempVal]] <- TRUE
          }
        }
      }
    },
    depthTraverse = function(start) {
      stack <- list(start)
      visited <- list()
      visited[[start]] = TRUE
      
      while(length(stack) > 0) {
        curVal = stack[length(stack)]
        print(curVal);
        stack <- stack[-length(stack)]
        tempArr = graphMap[[sprintf("%s", curVal)]]
        
        for(tempVal in tempArr) {
          if (tempVal %in% names(visited) == FALSE) {
            stack <- append(stack, tempVal)
            visited[[tempVal]] <- TRUE
          }
        }
      }
    }
  )
)

newGraph <- Graph()
newGraph$addNode("a")
newGraph$addVertices("a", "b")
newGraph$addVertices("a", "c")
newGraph$addVertices("b", "d")
newGraph$addVertices("b", "e")
newGraph$addVertices("d", "f")
newGraph$addVertices("d", "g")
newGraph$addVertices("d", "h")
newGraph$addVertices("e", "i")
newGraph$addVertices("e", "j")
newGraph$breadthTraverse("a")
newGraph$depthTraverse("a")

Ruby

class Graph
  def initialize
    @graphMap = Hash.new
  end
  
  def addNode(value)
    @graphMap[value] = []
  end
  
  def addVertices(node1, node2)
    if @graphMap.include?(node1) == false
      @graphMap[node1] = []
    end

    if @graphMap.include?(node2) == false
      @graphMap[node2] = []
    end

    @graphMap[node1] << node2
    @graphMap[node2] << node1
  end

  def breadthTraverse(start)
    queue = [start]
    visited = Hash.new
    visited[start] = true;

    while queue.length > 0
      currentVal = queue.shift()
      puts currentVal
      
      tempArr = @graphMap[currentVal]
      for tempVal in tempArr do
        if visited.include?(tempVal) == false
          queue << tempVal
          visited[tempVal] = true
        end
      end
    end
  end

  def depthTraverse(start)
    stack = [start]
    visited = Hash.new
    visited[start] = true;

    while stack.length > 0
      currentVal = stack.pop()
      puts currentVal
      
      tempArr = @graphMap[currentVal]
      for tempVal in tempArr do
        if visited.include?(tempVal) == false
          stack << tempVal
          visited[tempVal] = true
        end
      end
    end
  end
end

newGraph = Graph.new
newGraph.addNode("a")
newGraph.addVertices("a", "b")
newGraph.addVertices("a", "c")
newGraph.addVertices("b", "d")
newGraph.addVertices("b", "e")
newGraph.addVertices("d", "f")
newGraph.addVertices("d", "g")
newGraph.addVertices("d", "h")
newGraph.addVertices("e", "i")
newGraph.addVertices("e", "j")
newGraph.breadthTraverse("a")
newGraph.depthTraverse("a")

Rust

// No Native Support or Implementation

Scala

import scala.collection.mutable.Map
import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.Stack
import scala.collection.mutable.Queue

class Graph {
  var graphMap:Map[String, ArrayBuffer[String]] = Map()
  
  def addNode(value:String) {
    graphMap += (value -> ArrayBuffer[String]());
  }
  
  def addVertices(node1:String, node2:String) {
    if(graphMap.contains(node1) == false) {
      graphMap += (node1 -> ArrayBuffer());
    }
    
    if(graphMap.contains(node2) == false) {
      graphMap += (node2 -> ArrayBuffer());
    }
    
    graphMap(node1).append(node2);
    graphMap(node2).append(node1);
  }
  
  def breadthTraverse(start:String) {
    var queue = Queue(start);
    var visited:Map[String, Boolean] = Map();
    visited += (start -> true);
     
    while(queue.size > 0) {
      var currentVal = queue.front;
      print(currentVal + "\n");
      queue.dequeue;
      
      var tempArr = graphMap(currentVal)
      
      for (tempVal <- tempArr) {
        if(visited.contains(tempVal) == false) {
          queue.enqueue(tempVal);
          visited += (tempVal -> true);
        }
      }
    }
  }
  
  def depthTraverse(start:String) {
    var stack = Stack(start);
    var visited:Map[String, Boolean] = Map();
    visited += (start -> true);
     
    while(stack.size > 0) {
      var currentVal = stack.top;
      print(currentVal + "\n");
      stack.pop();
      
      var tempArr = graphMap(currentVal);
      
      for (tempVal <- tempArr) {
        if(visited.contains(tempVal) == false) {
          stack.push(tempVal);
          visited += (tempVal -> true);
        }
      }
    }
  }
}

val newGraph = new Graph;
newGraph.addNode("a");
newGraph.addVertices("a", "b");
newGraph.addVertices("a", "c");
newGraph.addVertices("b", "d");
newGraph.addVertices("b", "e");
newGraph.addVertices("d", "f");
newGraph.addVertices("d", "g");
newGraph.addVertices("d", "h");
newGraph.addVertices("e", "i");
newGraph.addVertices("e", "j");

newGraph.breadthTraverse("a");
newGraph.depthTraverse("a");

Swift

class Graph {
  var graphMap = [String: Array<String>]();
  
  func addNode(val:String) {
    graphMap[val] = [];
  }
  
  func addVertices(node1:String, node2:String) {
    if (graphMap[node1] == nil) {
      graphMap[node1] = [];
    }
        
    if (graphMap[node2]  == nil) {
      graphMap[node2] = [];
    }
    graphMap[node1]?.append(node2);
    graphMap[node2]?.append(node1);
  }
  
  func breadthTraverse(start:String) {
    var queue = [start];
    var visited = [String: Bool]();
    visited[start] = true;
    
    while(queue.count > 0) {
      let currentVal = queue[0];
      print(currentVal);
      queue.removeFirst();
      
      let tempArr = graphMap[currentVal] ?? [];
      
      for tempVal in tempArr {
        if visited[tempVal] == nil {
          queue.append(tempVal);
          visited[tempVal] = true;
        }
      }
    }
  }
  
  func depthTraverse(start:String) {
    var stack = [start];
    var visited = [String: Bool]();
    visited[start] = true;
    
    while(stack.count > 0) {
      let currentVal = stack[stack.count - 1];
      print(currentVal);
      stack.removeLast();
      
      let tempArr = graphMap[currentVal] ?? [];
      
      for tempVal in tempArr {
        if visited[tempVal] == nil  {
          stack.append(tempVal);
          visited[tempVal] = true;
        }
      }
    }
  }
}

var newGraph = Graph();
newGraph.addNode(val:"a");
newGraph.addVertices(node1:"a", node2:"b");
newGraph.addVertices(node1:"a", node2:"c");
newGraph.addVertices(node1:"b", node2:"d");
newGraph.addVertices(node1:"b", node2:"e");
newGraph.addVertices(node1:"d", node2:"f");
newGraph.addVertices(node1:"d", node2:"g");
newGraph.addVertices(node1:"d", node2:"h");
newGraph.addVertices(node1:"e", node2:"i");
newGraph.addVertices(node1:"e", node2:"j");
newGraph.breadthTraverse(start:"a");
newGraph.depthTraverse(start:"a");

TypeScript

class Graph {
  graphMap: {[key: string]: string[]}
  
  constructor() {
    this.graphMap = {};
  }
  
  addNode(val:string) {
   this.graphMap[val] = [];
  }
  
  addVertices(node1:string, node2:string) {
    if(!this.graphMap[node1]) {
      this.graphMap[node1] = [];
    }
    if(!this.graphMap[node2]) {
      this.graphMap[node2] = [];
    }

    this.graphMap[node1].push(node2);
    this.graphMap[node2].push(node1);
  }
  
  breadthTraverse(start:string) {
    const queue = [start];
    const visited:{[key: string]:boolean} = {};
    visited[start] = true;

    while(queue.length) {
      const val = queue.shift();
      console.log(val);

      const tempArr =
        this.graphMap[val as string];

      for (let i = 0; i < tempArr.length; i++) {
        if (!visited[tempArr[i]]) {
          queue.push(tempArr[i]);
          visited[tempArr[i]] = true;
        }
      }
    }
  }

  depthTraverse(start:string) {
    const stack = [start];
    const visited:{[key:string]:boolean} = {};
    visited[start] = true;

    while(stack.length) {
      const val = stack.pop();
      console.log(val);

      const tempArr =
        this.graphMap[val as string];

      for (let i = 0; i < tempArr.length; i++) {
        if (!visited[tempArr[i]]) {
          stack.push(tempArr[i]);
          visited[tempArr[i]] = true;
        }
      }
    }
  }
  
}

const newGraph = new Graph();
newGraph.addNode("a");
newGraph.addVertices("a", "b");
newGraph.addVertices("a", "c");
newGraph.addVertices("b", "d");
newGraph.addVertices("b", "e");
newGraph.addVertices("d", "f");
newGraph.addVertices("d", "g");
newGraph.addVertices("d", "h");
newGraph.addVertices("e", "i");
newGraph.addVertices("e", "j");
newGraph.breadthTraverse("a");
newGraph.depthTraverse("a");

Basics

Data Structure

Iterables

Classes

Regex