1. LinkedListCycle

2. SymmetricTree
3. UniqueBinarySearchTrees

Author: Ken-Yang

Java/src/net/kenyang/algorithm/LinkedListCycle.java

@@ -0,0 +1,38 @@
+package net.kenyang.algorithm;
+
+
+public class LinkedListCycle {
+    class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int x) {
+            val = x;
+            next = null;
+        }
+    }
+    
+
+    public boolean hasCycle(ListNode head) {
+
+        ListNode slowNode = head;
+        ListNode fastNode = head;
+        if (head !=null && head.next != null) {
+            fastNode = head.next;
+        } else {
+            return false;
+        }
+                
+        while (slowNode !=null && fastNode!=null){
+            if (slowNode.val == fastNode.val ) return true;
+            
+            slowNode = slowNode.next;
+            fastNode = fastNode.next;
+            if (fastNode!=null){
+                fastNode = fastNode.next;
+            }
+        }
+        
+        return false;
+    }
+}

Java/src/net/kenyang/algorithm/SymmetricTree.java

@@ -0,0 +1,37 @@
+package net.kenyang.algorithm;
+
+public class SymmetricTree {
+
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+
+    public boolean isSymmetric(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+
+        return isSymmetric(root.left, root.right);
+    }
+
+    public boolean isSymmetric(TreeNode leftNode, TreeNode rightNode) {
+        if (rightNode == null && leftNode == null)
+            return true;
+        if (rightNode == null)
+            return false;
+        if (leftNode == null)
+            return false;
+
+        
+        return leftNode.val == rightNode.val
+                && isSymmetric(leftNode.left, rightNode.right)
+                && isSymmetric(leftNode.right, rightNode.left);
+
+    }
+}

Java/src/net/kenyang/algorithm/UniqueBinarySearchTrees.java

@@ -0,0 +1,27 @@
+package net.kenyang.algorithm;
+
+/**
+ * Given n, how many structurally unique BST's (binary search trees) that store values 1...n?
+ * 
+ * For example,
+ * Given n = 3, there are a total of 5 unique BST's.
+ * @author Ken Yang
+ *
+ */
+public class UniqueBinarySearchTrees {
+    
+    
+    public int numTrees(int n) {
+        
+        if (n<2) {
+            return 1;
+        }
+        int ans = 0;
+        for(int i = 0; i < n; i++) {
+            ans += numTrees(i) * numTrees(n-i-1);
+        }
+        return ans;
+        
+    }
+    
+}