Merge branch 'master' into master

Author: Bhrigu Kansra

Algorithms/HuffmanEncoder.java

@@ -0,0 +1,91 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.PriorityQueue;
+
+public class HuffmanEncoder {
+	private HashMap<Character, String> encoder = new HashMap<>();
+	private HashMap<String, Character> decoder = new HashMap<>();
+
+	private class Node implements Comparable<Node> {
+		char data;
+		int freq;
+		Node left;
+		Node right;
+
+		@Override
+		public int compareTo(Node o) {
+			return this.freq - o.freq;
+		}
+	}
+
+	public HuffmanEncoder(String feeder) {
+		// Step 1 -> Feeder to fmap
+		HashMap<Character, Integer> fmap = new HashMap<>();
+
+		for (int i = 0; i < feeder.length(); i++) {
+			char ch = feeder.charAt(i);
+			fmap.put(ch, fmap.containsKey(ch) ? fmap.get(ch) + 1 : 1);
+		}
+
+		// Step 2 -> fmap to Priority Queue
+		ArrayList<Character> keys = new ArrayList<>(fmap.keySet());
+		PriorityQueue<Node> pq = new PriorityQueue<>();
+		for (Character key : keys) {
+			Node node = new Node();
+			node.freq = fmap.get(key);
+			node.data = key;
+			pq.add(node);
+		}
+
+		// Step 3 -> while PQ.size > 1, remove 2 from PQ, merge them and add in
+		// PQ
+		while (pq.size() > 1) {
+			Node one = pq.remove();
+			Node two = pq.remove();
+			Node merged = new Node();
+			merged.freq = one.freq + two.freq;
+			merged.left = one;
+			merged.right = two;
+			pq.add(merged);
+		}
+
+		Node lastNodeInPQ = pq.remove();
+		traverse(lastNodeInPQ, "");
+		System.out.println(encoder);
+	}
+
+	private void traverse(Node node, String psf) {
+		if (node.left == null && node.right == null) {
+			encoder.put(node.data, psf);
+			decoder.put(psf, node.data);
+			return;
+		}
+		traverse(node.left, psf + "0");
+		traverse(node.right, psf + "1");
+	}
+
+	public String encode(String str) {
+		String coded = "";
+		for (int i = 0; i < str.length(); i++) {
+			coded += encoder.get(str.charAt(i));
+		}
+
+		return coded;
+	}
+
+	public String decode(String str) {
+		String ch = "";
+		String decoded = "";
+		
+		for (int i = 0; i < str.length(); i++) {
+			ch += str.substring(i, i + 1);
+			if (decoder.containsKey(ch)) {
+				decoded += decoder.get(ch);
+				ch = "";
+			}
+		}
+
+		return decoded;
+	}
+
+}

Graph/BFS.java

@@ -0,0 +1,83 @@
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class BFS {
+
+	public static void main(String[] args) {
+		Graph G = new Graph(8);
+		G.addEdge(0, 1);
+		G.addEdge(2, 3);
+		G.addEdge(0, 4);
+		G.addEdge(5, 6);
+		G.addEdge(2, 5);
+		G.addEdge(2, 6);
+		G.addEdge(1, 5);
+		G.addEdge(6, 7);
+		G.addEdge(3, 6);
+		G.addEdge(3, 7);
+		BFS b = new BFS();
+		b.bfs(G, 1);
+	}
+	
+	public void bfs(Graph G,int s) {
+		int[] color = new int[G.V()]; //0-White,1-Gray,2-Black
+		int[] d = new int[G.V()]; //distance from source
+		int[] p = new int[G.V()]; // parent
+		Arrays.fill(d, -1);
+		Arrays.fill(p, -1);
+		ArrayDeque<Integer> q = new ArrayDeque<>();
+		
+		color[s]=1;
+		d[s]=0;
+		p[s]=-1; //parent of source in BFS tree is NIL
+		q.add(s);
+		while(!q.isEmpty()) {
+			int u = q.poll();
+			for(int v:G.adj[u]) {
+				if(color[v]==0) { //if color is white
+					color[v]=1;   //make it Grey
+					d[v]=d[u]+1;  // update distance from source
+					p[v]=u;       // update parent
+					q.add(v);
+				}
+			}
+			color[u]=2; //change color to black when all adjacent of u are discovered
+		}
+		System.out.println(Arrays.toString(color));
+		System.out.println(Arrays.toString(d));
+		System.out.println(Arrays.toString(p));
+	}
+	
+	static class Graph {
+		private final int V;
+		private int E;
+		private ArrayList<Integer>[] adj;
+
+		public Graph(int V) {
+			this.V = V;
+			adj = new ArrayList[V];
+			for (int v = 0; v < V; v++) {
+				adj[v] = new ArrayList<Integer>();
+			}
+		}
+
+		public int V() {
+			return V;
+		}
+
+		public int E() {
+			return E;
+		}
+
+		public void addEdge(int v, int w) {
+			adj[v].add(w);
+			adj[w].add(v);
+			E++;
+		}
+
+		public Iterable<Integer> adj(int v) {
+			return adj[v];
+		}
+	}
+}

Graph/BFS.py

@@ -0,0 +1,39 @@
+"""pseudo-code"""
+
+"""
+BFS(graph G, start vertex s):
+// all nodes initially unexplored
+mark s as explored
+let Q = queue data structure, initialized with s
+while Q is non-empty:
+    remove the first node of Q, call it v
+    for each edge(v, w):  // for w in graph[v]
+        if w unexplored:
+            mark w as explored
+            add w to Q (at the end)
+
+"""
+
+import collections
+
+
+def bfs(graph, start):
+    explored, queue = set(), [start]  # collections.deque([start])
+    explored.add(start)
+    while queue:
+        v = queue.pop(0)  # queue.popleft()
+        for w in graph[v]:
+            if w not in explored:
+                explored.add(w)
+                queue.append(w)
+    return explored
+
+
+G = {'A': ['B', 'C'],
+     'B': ['A', 'D', 'E'],
+     'C': ['A', 'F'],
+     'D': ['B'],
+     'E': ['B', 'F'],
+     'F': ['C', 'E']}
+
+print(bfs(G, 'A'))

Graph/DFS.java

@@ -0,0 +1,74 @@
+import java.util.*;
+
+public class DFS {
+//////////simple DFS//////////////////
+	private static boolean[] marked;
+	private static int count;
+
+	public static void dfsUtil(Graph G, int s) {
+		marked = new boolean[G.V()];
+		dfs(G, s);
+	}
+
+	private static void dfs(Graph G, int v) {
+		marked[v] = true;
+		count++;
+		for (int w : G.adj(v)) {
+			if (!marked[w]) {
+				dfs(G, w);
+			}
+		}
+	}
+	
+	public static boolean isMarked(int w) {
+		return marked[w];
+	}
+	
+	public static int count() {
+		return count;
+	}
+////////////////////////////////////////
+	static class Graph {
+		private final int V; // vertices
+		private int E; // edges
+		ArrayList<Integer>[] adj; // adjacency list
+
+		public Graph(int V) {
+			this.V = V;
+			adj = new ArrayList[V];
+			for (int v = 0; v < V; v++) {
+				adj[v] = new ArrayList<Integer>();
+			}
+		}
+
+		public int V() {
+			return V;
+		}
+
+		public int E() {
+			return E;
+		}
+
+		public void addEdge(int v, int w) {
+			adj[v].add(w);
+			adj[w].add(v);
+			E++;
+		}
+
+		public Iterable<Integer> adj(int v) {
+			return adj[v];
+		}
+	}
+
+	public static void main(String[] args) {
+		int v=3;  //no of vertex 
+		Graph G = new Graph(v);
+		G.addEdge(0, 1);
+		G.addEdge(1, 2);
+		G.addEdge(2, 0);
+		int source=1;
+		dfsUtil(G, source);
+		System.out.println(isMarked(2));       //tell reachable from source or not
+		System.out.println(count);			   //number of vertices reachable from source	
+	}
+}

Graph/DFS.py

@@ -0,0 +1,36 @@
+"""pseudo-code"""
+
+"""
+DFS(graph G, start vertex s):
+// all nodes initially unexplored
+mark s as explored
+for every edge (s, v):
+    if v unexplored:
+        DFS(G, v)
+"""
+
+
+def dfs(graph, start):
+    """The DFS function simply calls itself recursively for every unvisited child of its argument. We can emulate that
+     behaviour precisely using a stack of iterators. Instead of recursively calling with a node, we'll push an iterator
+      to the node's children onto the iterator stack. When the iterator at the top of the stack terminates, we'll pop
+       it off the stack."""
+    explored, stack = set(), [start]
+    explored.add(start)
+    while stack:
+        v = stack.pop()  # the only difference from BFS is to pop last element here instead of first one
+        for w in graph[v]:
+            if w not in explored:
+                explored.add(w)
+                stack.append(w)
+    return explored
+
+
+G = {'A': ['B', 'C'],
+     'B': ['A', 'D', 'E'],
+     'C': ['A', 'F'],
+     'D': ['B'],
+     'E': ['B', 'F'],
+     'F': ['C', 'E']}
+
+print(dfs(G, 'A'))

Graph/filename.md

@@ -0,0 +1 @@
+