add

Change-Id: Ib581f574559afe39c0f5e22fb79ffec45a3f56bf

Author: applewjg

BinaryTreePreorderTraversal.java

@@ -0,0 +1,110 @@
+/*
+ Author:     King, [email protected]
+ Date:       Dec 25, 2014
+ Problem:    Binary Tree Preorder Traversal
+ Difficulty: Easy
+ Source:     http://oj.leetcode.com/problems/binary-tree-preorder-traversal/
+ Notes:
+ Given a binary tree, return the preorder traversal of its nodes' values.
+ For example:
+ Given binary tree {1,#,2,3},
+    1
+     \
+      2
+     /
+    3
+ return [1,2,3].
+ Note: Recursive solution is trivial, could you do it iteratively?
+
+ Solution: 1. Iterative way (stack).   Time: O(n), Space: O(n).
+           2. Recursive solution.      Time: O(n), Space: O(n).
+           3. Threaded tree (Morris).  Time: O(n), Space: O(1).
+ */
+
+/**
+ * Definition for binary tree
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public List<Integer> preorderTraversal_1(TreeNode root) {
+        List<Integer> res = new ArrayList<Integer>();
+        if(root == null) return res;
+        res.add(root.val);
+        List<Integer> left = preorderTraversal(root.left);
+        List<Integer> right = preorderTraversal(root.right);
+        res.addAll(left);
+        res.addAll(right);
+        return res;
+    }
+    public void preorderTraversalRe(TreeNode root, List<Integer> res) {
+        if (root == null) return;
+        res.add(root.val);
+        preorderTraversalRe(root.left, res);
+        preorderTraversalRe(root.right, res);
+    }
+    public List<Integer> preorderTraversal_2(TreeNode root) {
+        List<Integer> res = new ArrayList<Integer>();
+        if(root == null) return res;
+        preorderTraversalRe(root, res);
+        return res;
+    }
+    public List<Integer> preorderTraversal_3(TreeNode root) {
+        List<Integer> res = new ArrayList<Integer>();
+        if(root == null) return res;
+        Stack<TreeNode> stk = new Stack<TreeNode>();
+        stk.push(root);
+        while (stk.isEmpty() == false) {
+            TreeNode cur = stk.pop();
+            res.add(cur.val);
+            if (cur.right != null) stk.push(cur.right);
+            if (cur.left != null) stk.push(cur.left);
+        }
+        return res;
+    }
+    public List<Integer> preorderTraversal_4(TreeNode root) {
+        List<Integer> res = new ArrayList<Integer>();
+        if(root == null) return res;
+        Stack<TreeNode> stk = new Stack<TreeNode>();
+        TreeNode cur = root;
+        while (stk.isEmpty() == false || cur != null) {
+            if (cur != null) {
+                stk.push(cur);
+                res.add(cur.val);
+                cur = cur.left;
+            } else {
+                cur = stk.pop();
+                cur = cur.right;
+            }
+        }
+        return res;
+    }
+    public List<Integer> preorderTraversal_5(TreeNode root) {
+        List<Integer> res = new ArrayList<Integer>();
+        if(root == null) return res;
+        TreeNode cur = root;
+        while (cur) {
+            if (cur.left == null) {
+                res.add(cur.val);
+                cur = cur.right;
+            } else {
+                TreeNode node = cur.left;
+                while (node.right != null && node.right != cur)
+                    node = node.right;
+                if (node == null) {
+                    node.right = cur;
+                    res.add(cur.val);
+                    cur = cur.left;
+                } else {
+                    node.right = null;
+                    cur = cur.right;
+                }
+            }
+        }
+        return res;
+    }
+}

RotateImage.java

@@ -0,0 +1,53 @@
+/*
+ Author:     King, [email protected]
+ Date:       Dec 25, 2014
+ Problem:    Rotate Image
+ Difficulty: Easy
+ Source:     https://oj.leetcode.com/problems/rotate-image/
+ Notes:
+ You are given an n x n 2D matrix representing an image.
+ Rotate the image by 90 degrees (clockwise).
+ Follow up:
+ Could you do this in-place?
+
+ Solution: 1. 123   ->  147   ->   741    (preferable)
+              456       258        852
+              789       369        963
+           2. Rotate one-fourth of the image clockwise.
+ */
+public class Solution {
+    public void rotate_1(int[][] matrix) {
+        int n = matrix.length;
+        if (n <= 1) return;
+        for(int i=0;i<n;i++){
+            for(int j=0;j<i;j++){
+                int tmp = matrix[i][j];
+                matrix[i][j]=matrix[j][i];
+                matrix[j][i]=tmp;
+            }
+        }
+        
+        for(int i=0;i<n;i++){
+            for(int j=0;j<n/2;j++){
+                int tmp = matrix[i][j];
+                matrix[i][j]=matrix[i][n-1-j];
+                matrix[i][n-1-j] = tmp;
+            }
+        }
+    }
+    public void rotate_2(int[][] matrix) {
+        int n = matrix.length;
+        if (n <= 1) return;
+        int level = 0;
+        while (level < n / 2) {
+            for (int i = level; i < n - 1 - level; ++i) {
+                int tmp = matrix[i][level];
+                matrix[i][level] = matrix[n - 1 - level][i];
+                matrix[n - 1 - level][i] = matrix[n - 1 - i][n - 1 - level];
+                matrix[n - 1 - i][n - 1 - level] = matrix[level][n - 1 - i];
+                matrix[level][n - 1 - i] = tmp;
+            }
+            ++level;
+        }
+    }
+}

RotateList.java

@@ -0,0 +1,55 @@
+/*
+ Author:     King, [email protected]
+ Date:       Dec 25, 2014
+ Problem:    Rotate List
+ Difficulty: Easy
+ Source:     https://oj.leetcode.com/problems/rotate-list/
+ Notes:
+ Given a list, rotate the list to the right by k places, where k is non-negative.
+
+ For example:
+ Given 1->2->3->4->5->NULL and k = 2,
+ return 4->5->1->2->3->NULL.
+
+ Solution: Notice that k can be larger than the list size (k % list_size).
+           This solution traverses the list twice at most.
+*/
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode rotateRight(ListNode head, int k) {
+        if (head == null) return head;
+        int n = 1;
+        ListNode tail = head, cur = head;
+        while (tail.next != null) {
+            tail = tail.next;
+            ++n;
+        }
+        k = k % n;
+        if (k == 0) return head;
+        for (int i = 0; i < n - k - 1; ++i) 
+            cur = cur.next;
+        ListNode newHead = cur.next;
+        tail.next = head;
+        cur.next = null;
+        return newHead;
+    }
+}

ScrambleString.java

@@ -0,0 +1,91 @@
+/*
+ Author:     King, [email protected]
+ Date:       Dec 25, 2014
+ Problem:    Scramble String
+ Difficulty: Medium
+ Source:     https://oj.leetcode.com/problems/scramble-string/
+ Notes:
+ Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.
+ Below is one possible representation of s1 = "great":
+    great
+   /    \
+  gr    eat
+ / \    /  \
+g   r  e   at
+           / \
+          a   t
+ To scramble the string, we may choose any non-leaf node and swap its two children.
+ For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".
+       rgeat
+      /     \
+     rg    eat
+    / \    /  \
+   r   g  e   at
+              / \
+             a   t
+ We say that "rgeat" is a scrambled string of "great".
+ Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".
+      rgtae
+      /    \
+     rg    tae
+    / \    /  \
+   r   g  ta  e
+          / \
+         t   a
+ We say that "rgtae" is a scrambled string of "great".
+ Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.
+
+ Solution: 1. Recursion + pruning.
+           2. 3-dimensional dp.
+              'dp[k][i][j] == true' means string s1(start from i, length k) is a scrambled string of string s2(start from j, length k).
+ */
+public class Solution {
+    public boolean isScramble_1(String s1, String s2) {
+        if (s1.compareTo(s2) == 0) return true;
+        if (s1.length() != s2.length()) return false;
+        return isScrambleRe(s1, s2);
+    }
+    public boolean isScrambleRe(String s1, String s2) {
+        if (hasSameLetters(s1, s2) == false) return false;
+        int len = s1.length();
+        if (len == 0 || len == 1) return true;
+        for (int i = 1; i < len; ++i) {
+            if (isScrambleRe(s1.substring(0,i), s2.substring(0,i)) 
+                && isScrambleRe(s1.substring(i), s2.substring(i)) 
+                || isScrambleRe(s1.substring(0,i), s2.substring(len-i)) 
+                && isScrambleRe(s1.substring(i), s2.substring(0,len-i))) {
+                    return true;
+                }
+        }
+        return false;
+    }
+    public boolean hasSameLetters(String s1, String s2) {
+        if (s1.compareTo(s2) == 0) return true;
+        if (s1.length() != s2.length()) return false;
+        int[] count = new int[256];
+        for (int i = 0; i < s1.length(); ++i) count[(int)s1.charAt(i)]++;
+        for (int i = 0; i < s2.length(); ++i) count[(int)s2.charAt(i)]--;
+        for (int i = 0; i < 256; ++i)
+            if (count[i] != 0) return false;
+        return true;
+    }
+    public boolean isScramble(String s1, String s2) {
+        if (s1.compareTo(s2) == 0) return true;
+        if (s1.length() != s2.length()) return false;
+        int N = s1.length();
+        boolean[][][] dp = new boolean[N+1][N][N];
+        for (int k = 1; k <= N; ++k) {
+            for (int i = 0; i <= N - k; ++i) {
+                for (int j = 0; j <= N - k; ++j) {
+                    dp[k][i][j] = false;
+                    if (k == 1) dp[1][i][j] = (s1.charAt(i) == s2.charAt(j));
+                    for (int p = 1; p < k && !dp[k][i][j]; ++p) {
+                        if (dp[p][i][j] && dp[k-p][i+p][j+p] || dp[p][i][j+k-p] && dp[k-p][i+p][j])
+                            dp[k][i][j] = true;
+                    }
+                }
+            }
+        }
+        return dp[N][0][0];
+    }
+}