Leetcode

100.txt

@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool isSameTree(TreeNode* p, TreeNode* q) {
+        //check the node itself
+        if(p==NULL && q==NULL) return true;
+        else
+            if(p==NULL||q==NULL) return false;
+            else
+            {
+                if(p->val != q->val) return false;
+                else
+                    //check the child nodes
+                    isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
+            }
+    }
+};

101.txt

@@ -0,0 +1,95 @@
+Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
+
+For example, this binary tree is symmetric:
+
+    1
+   / \
+  2   2
+ / \ / \
+3  4 4  3
+
+But the following is not:
+
+    1
+   / \
+  2   2
+   \   \
+   3    3
+
+Note:
+Bonus points if you could solve it both recursively and iteratively.
+
+confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.
+
+OJ's Binary Tree Serialization:
+
+The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.
+
+Here's an example:
+
+   1
+  / \
+ 2   3
+    /
+   4
+    \
+     5
+
+The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}". 
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+// use recursion
+class Solution {
+public:
+    bool DFS(TreeNode* left, TreeNode* right)
+    {
+        if(left == NULL && right == NULL) return true;
+        if(left == NULL || right == NULL) return false;
+        if(left->val != right->val) return false;
+        else
+            return DFS(left->left,right->right) && DFS(left->right, right->left);
+    }
+    bool isSymmetric(TreeNode* root) {
+        if(root == NULL) return true;
+        return DFS(root->left, root->right);
+    }
+};
+
+// use two queues to record the left and right branch
+class Solution {
+public:
+    bool isSymmetric(TreeNode* root) {
+        if(root == NULL) return true;
+        TreeNode *left, *right;
+        queue<TreeNode*> q1, q2;
+        q1.push(root->left);
+        q2.push(root->right);
+        while(!q1.empty() && !q2.empty())
+        {
+            left = q1.front();
+            q1.pop();
+            right = q2.front();
+            q2.pop();
+
+            if(left == NULL && right == NULL) continue;
+            if(left == NULL || right == NULL) return false;
+            if(left->val != right->val) return false;
+            else
+            {
+                q1.push(left->left);
+                q1.push(left->right);
+                q2.push(right->right);
+                q2.push(right->left);
+            }
+        }
+        return true;
+    }
+};

104.txt

@@ -0,0 +1,20 @@
+//Maximum Depth of Binary Tree
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+        if (root == NULL)
+            return 0;
+        else
+            return 1 + max(maxDepth(root->left), maxDepth(root->right));
+    }
+};

110.txt

@@ -0,0 +1,50 @@
+Given a binary tree, determine if it is height-balanced.
+For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+// top to down
+class Solution {
+public:
+    int depth(TreeNode* root){
+        if(root == NULL)
+            return 0;
+        else
+            return max(depth(root->left), depth(root->right)) + 1;
+    }
+    bool isBalanced(TreeNode* root) {
+        if(root == NULL) return true;
+        int ld = depth(root->left);
+        int rd = depth(root->right);
+        if(abs(ld-rd) > 1)
+            return false;
+        else
+            return isBalanced(root->left) && isBalanced(root->right);
+    }
+};
+
+// bottom up
+class Solution {
+public:
+    //if not balance ,return -1; else return the depth
+    int balanceness(TreeNode* root){
+        if(root == NULL) return 0;
+        int ld = balanceness(root->left);
+        if(ld == -1) return -1;
+        int rd = balanceness(root->right);
+        if(rd == -1) return -1;
+        if(abs(ld - rd) > 1) return -1;
+        return max(ld, rd) + 1;
+    }
+    bool isBalanced(TreeNode* root) {
+        return balanceness(root) != -1;
+    }
+};

112.txt

@@ -0,0 +1,31 @@
+Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
+For example:
+Given the below binary tree and sum = 22,
+
+              5
+             / \
+            4   8
+           /   / \
+          11  13  4
+         /  \      \
+        7    2      1
+
+return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasPathSum(TreeNode* root, int sum) {
+        if(root == NULL) return false;
+        if(root->left == NULL && root->right == NULL && sum == root->val) return true;
+        return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
+    }
+};

118.txt

@@ -0,0 +1,32 @@
+Given numRows, generate the first numRows of Pascal's triangle.
+For example, given numRows = 5,
+Return
+[
+     [1],
+    [1,1],
+   [1,2,1],
+  [1,3,3,1],
+ [1,4,6,4,1]
+]
+
+class Solution {
+public:
+    vector<vector<int>> generate(int numRows) {
+        vector<vector<int>> pascal;
+        pascal.resize(numRows);
+        for(int i = 1; i <= numRows; i++)
+            pascal[i - 1].resize(i);
+
+        for(int i = 0; i < numRows; i++)
+            for(int j = 0; j < i + 1; j++)
+            {
+                if(j == 0) pascal[i][j] = 1;
+                else
+                    if(j == i) pascal[i][j] = 1;
+                    else
+                        pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
+            }
+
+        return pascal;
+    }
+};

119.txt

@@ -0,0 +1,21 @@
+Given an index k, return the kth row of the Pascal's triangle.
+
+For example, given k = 3,
+Return [1,3,3,1].
+
+Note:
+Could you optimize your algorithm to use only O(k) extra space? 
+
+// use O(k) extra space
+class Solution {
+public:
+    vector<int> getRow(int rowIndex) {
+        vector<int> pascal(rowIndex + 1, 0);
+        pascal[0] = 1;
+
+        for(int i = 1; i < rowIndex + 1; i++)
+            for(int j = i; j >= 1; j--)
+                pascal[j] += pascal[j - 1];
+        return pascal;
+    }
+};

13.txt

@@ -0,0 +1,33 @@
+Given a roman numeral, convert it to an integer.
+
+Input is guaranteed to be within the range from 1 to 3999.
+
+// the Roman alphabet is listed in the switch statement below
+class Solution {
+public:
+    int decode(char c){
+        switch(c){
+            case 'I': return 1;
+            case 'V': return 5;
+            case 'X': return 10;
+            case 'L': return 50;
+            case 'C': return 100;
+            case 'D': return 500;
+            case 'M': return 1000;
+        }
+    }
+
+    int romanToInt(string s) {
+        int n = 0;
+        int n1, n2;
+        for(int i = 0; i < s.size() - 1; i++)
+        {
+            n1 = decode(s[i]);
+            n2 = decode(s[i + 1]);
+            if(n1 < n2) n -= n1;
+            else n += n1;
+        }
+        n += decode(s[s.size()-1]);
+        return n;
+    }
+};

136.txt

@@ -0,0 +1,14 @@
+//Given an array of integers, every element appears twice except for one. Find that single one.
+
+//Note:
+//Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory? 
+
+// A ^ A = 0, 0 ^ A = 0, A ^ B ^ A = B
+class Solution {
+public:
+    int singleNumber(vector<int>& nums) {
+        for(int i = 1; i < nums.size(); i++)
+            nums[0] = nums[0] ^ nums[i];
+        return nums[0];
+    }
+};

168.txt

@@ -0,0 +1,47 @@
+Given a positive integer, return its corresponding column title as appear in an Excel sheet.
+For example:
+
+    1 -> A
+    2 -> B
+    3 -> C
+    ...
+    26 -> Z
+    27 -> AA
+    28 -> AB 
+
+
+class Solution {
+public:
+    string convertToTitle(int n) {
+        string result, s_tmp;
+        char ch_tmp;
+        int tail = 0;
+        while(n > 0)
+        {
+            tail = n % 26;
+            if(tail == 0)
+            {
+                tail = 26;
+                result = "Z" + result;
+            }
+            else
+            {
+		        ch_tmp = 'A' - 1 + tail;
+		        s_tmp = ch_tmp;
+		        result = s_tmp + result;
+            }
+            n = (n - tail)/26;
+	    }
+
+		/*
+		while(n){
+			n -= 1;
+			ch_tmp = 'A' + n % 26;
+			result = ch_tmp + result;
+			n /= 26;
+		}
+		*/
+
+		return result;
+    }
+};