Solution added.

Author: yuduozhou

AddTwoNumbers.java

@@ -0,0 +1,58 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        int carry = 0;
+        ListNode dummy = new ListNode(0);
+        while (l1 != null || l2 != null){
+            int sum = carry + getVal(l1) + getVal(l2);
+            carry = sum / 10;
+            
+            ListNode current = new ListNode(sum % 10);
+            current.next = dummy.next;
+            dummy.next = current;
+            l1 = getNext(l1);
+            l2 = getNext(l2);
+        }
+        if (carry != 0){
+            ListNode head = new ListNode(carry);
+            head.next = dummy.next;
+            dummy.next = head;
+        }
+        return reverse(dummy.next);
+    }
+    
+    public int getVal(ListNode node){
+        if (node == null) return 0;
+        return node.val;
+        
+    }
+    
+    public ListNode getNext(ListNode node){
+        if (node == null) return null;
+        return node.next;
+    }
+    
+    public ListNode reverse(ListNode head) {
+        ListNode current = head;
+        ListNode newHead = null;
+        while (current != null) {
+            ListNode tmp = current;
+            current = current.next;
+            tmp.next = newHead;
+            newHead = tmp;
+        }
+        return newHead;
+    }
+}

Anagrams.java

@@ -0,0 +1,49 @@
+import java.util.*;
+
+public class Solution {
+    public ArrayList<String> anagrams(String[] strs) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        ArrayList<String> result = new ArrayList<String>();
+        HashMap<String, ArrayList<Integer>> ruler = new HashMap<String, ArrayList<Integer>>();
+
+        for (int i = 0; i < strs.length; i ++){
+            ArrayList<Integer> temp =  new ArrayList<Integer>();
+            String hash = hashWord(strs[i]);
+            if (ruler.containsKey(hash)){
+                temp = ruler.get(hash);
+            }
+            temp.add(i);
+            ruler.put(hash, temp);
+
+        }
+
+        Iterator it = ruler.entrySet().iterator(); 
+        while(it.hasNext()) { 
+            Map.Entry me = (Map.Entry)it.next();
+            ArrayList<Integer> values = (ArrayList<Integer>) me.getValue();
+            if (values.size() > 1){
+                for (int index = 0; index < values.size(); index ++){
+                    result.add(strs[values.get(index)]);
+                }
+            }
+        }
+        return result;
+    }
+    
+    public String hashWord(String word){
+        int[] letters = new int[26];
+        for (int i = 0; i < 26; i ++) {
+            letters[i] = 0;
+        }
+        for (int i = 0; i < word.length(); i++) {
+            int index = (int) word.charAt(i) - 97;
+            letters[index] ++;
+        }
+        String result = "";
+        for (int i: letters){
+            result += i + "/";
+        }
+        return result;
+    }
+}

InOrderTraversal.java

@@ -0,0 +1,16 @@
+public class Solution {
+    public ArrayList<Integer> inorderTraversal(TreeNode root) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        ArrayList<Integer> result = new ArrayList<Integer>();
+        inOrder(root, result);
+        return result;
+    }
+    
+    public void inOrder(TreeNode root, ArrayList<Integer> result){
+        if (root ==  null) return;
+        inOrder(root.left, result);
+        result.add(root.val);
+        inOrder(root.right, result);
+    }
+}