Add alien dictionary solution

Author: sudheerj

src/java1/algorithms/graph/AlienDictionary.java

@@ -0,0 +1,66 @@
+package java1.algorithms.graph;
+
+import java.util.*;
+
+public class AlienDictionary {
+
+    //BFS(Topological sorting through Kahn's alogirthm):- TC: O(m*n) SC:O(m*n)
+    private static String alienOrder(String[] words) {
+        if(words == null || words.length == 0) return null;
+
+        Map<Character, List<Character>> adjList = new HashMap<>();
+        int[] inDegree = new int[26];
+
+        for(int i=0; i< words.length-1; i++) {
+            String currWord = words[i], nextWord = words[i+1];
+            if(currWord.length() > nextWord.length() && currWord.substring(0, nextWord.length()).equals(nextWord)) {
+                return "";
+            }
+            for(int j=0; j< Math.min(currWord.length(), nextWord.length()); j++) {
+                char ch1 = currWord.charAt(j);
+                char ch2 = nextWord.charAt(j);
+                if(ch1 != ch2) {
+                    if(!adjList.containsKey(ch1)) {
+                        adjList.put(ch1, new ArrayList<>());
+                    }
+                    adjList.get(ch1).add(ch2);
+                    inDegree[ch2- 'a']++;
+                    break;
+                }
+            }
+        }
+
+        Set<Character> uniqueLetters = new HashSet<>();
+        for(String word: words) {
+            for(char ch: word.toCharArray()) {
+                uniqueLetters.add(ch);
+            }
+        }
+
+        PriorityQueue<Character> queue = new PriorityQueue<>();
+        for(char ch: uniqueLetters) {
+            if(inDegree[ch-'a'] == 0) {
+                queue.add(ch);
+            }
+        }
+
+        String topSort = "";
+        while(!queue.isEmpty()) {
+            char ch = queue.poll();
+            topSort += ch;
+            if(adjList.get(ch) == null) continue;
+            for(char neighbour: adjList.get(ch)) {
+                if(--inDegree[neighbour-'a'] == 0) {
+                    queue.add(neighbour);
+                }
+            }
+        }
+        return topSort.length() == uniqueLetters.size() ? topSort : "";
+    }
+
+    public static void main(String[] args) {
+        String[] words =  {"wrt", "wrf", "er", "ett", "rftt"};
+        System.out.println(alienOrder(words));
+    }
+    
+}

src/javascript/algorithms/graph/alienDictionary.js

@@ -0,0 +1,61 @@
+//BFS(Topological sorting through Kahn's alogirthm):- TC: O(m*n) SC:O(m*n)
+
+function alienOrder(words) {
+    let adjList = {};
+    let inDegree = Array(26).fill(0);
+    let uniqueLetters = new Set();
+
+    for(let i=0; i< words.length-1; i++) {
+        let currWord = words[i];
+        let nextWord = words[i+1];
+
+        if(currWord.length > nextWord.length && currWord.startsWith(nextWord)) {
+            return "";
+        }
+        for(let j=0; j< Math.min(currWord.length, nextWord.length); j++) {
+            let ch1 = currWord[j];
+            let ch2 = nextWord[j];
+            if(ch1 !== ch2) {
+                if(!adjList[ch1]) {
+                    adjList[ch1] = [];
+                }
+                adjList[ch1].push(ch2);
+                inDegree[ch2.charCodeAt(0)-97]++;
+                break;
+            }
+        }
+
+    }
+
+    for(let word of words) {
+        for(let ch of word) {
+            uniqueLetters.add(ch);
+        }
+    }
+
+    let queue = [];
+    for(let ch of uniqueLetters) {
+        if(inDegree[ch.charCodeAt(0)-97] === 0) {
+            queue.push(ch);
+        }
+    }
+
+    let topStr = "";
+    while(queue.length >0) {
+        let currChar = queue.shift();
+        topStr += currChar;
+        if(!adjList[currChar]) continue;
+        for(let neighbour of adjList[currChar]) {
+            if(--inDegree[neighbour.charCodeAt(0)-97] === 0) {
+                queue.push(neighbour);
+            }
+        }
+    }
+
+    return topStr.length === uniqueLetters.size ? topStr : "";
+    
+}
+
+let words =  ["wrt", "wrf", "er", "ett", "rftt"];
+console.log(alienOrder(words));
+