Merge branch 'master' of github.com:cls1991/leetcode

cls1991 · cls1991 · commit d8e35a599aa3 · 2018-02-08T17:49:15.000+08:00
diff --git a/Tree/llb/437. Path Sum III.cpp b/Tree/llb/437. Path Sum III.cpp
@@ -0,0 +1,90 @@
+/*
+问题描述：
+You are given a binary tree in which each node contains an integer value.
+
+Find the number of paths that sum to a given value.
+
+The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).
+
+The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.
+
+Example:
+
+root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
+
+      10
+     /  \
+    5   -3
+   / \    \
+  3   2   11
+ / \   \
+3  -2   1
+
+Return 3. The paths that sum to 8 are:
+
+1.  5 -> 3
+2.  5 -> 2 -> 1
+3. -3 -> 11
+*/
+
+/**
+ * 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:
+    
+    /*思考：
+    利用前序遍历的思想，对于每个遍历到的节点进行处理，维护一个变量pre来记录之前路径的和，
+    然后加上当前节点值，如果加上之后路径之和为sum，那么返回时要加一，然后递归调用左右子树
+    */
+    /*
+    int pathSum(TreeNode* root, int sum) {
+        if (!root)
+            return 0;
+        return help(root, 0, sum) + pathSum(root->left, sum) + pathSum(root->right, sum);
+    }
+    
+    int help (TreeNode* node, int pre, int &sum) {
+        if (!node) 
+            return 0;
+        int cur = pre + node->val;
+        return (cur == sum) + help(node->left, cur, sum) + help(node->right, cur, sum);
+    }
+    */
+    
+    //思考二：
+    int pathSum(TreeNode* root, int sum) {
+        int count = 0;
+        vector<TreeNode*> vec;
+        helper(root, sum, 0, vec, count);
+        return count;
+    }
+    
+    void helper(TreeNode* node, int sum, int curSum, vector<TreeNode*> &vec, int &count) {
+        if (!node) 
+            return;
+        
+        curSum += node->val;
+        vec.push_back(node);
+        //如果加入该节点后，值相等了，就多了条
+        if (curSum == sum) 
+            count++;
+        int temp = curSum;
+        //再判断加上该点后，它与之前的子路径之和
+        for (int i=0; i<vec.size()-1; ++i) {
+            temp -= vec[i]->val;
+            if (temp == sum) 
+                count++;
+        }
+        //然后判断左右子树
+        helper(node->left, sum, curSum, vec, count);
+        helper(node->right, sum, curSum, vec, count);
+        vec.pop_back();
+    }
+};
diff --git a/Tree/llb/449. Serialize and Deserialize BST.cpp b/Tree/llb/449. Serialize and Deserialize BST.cpp
@@ -0,0 +1,132 @@
+/*
+问题描述：
+Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.
+
+Design an algorithm to serialize and deserialize a binary search tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary search tree can be serialized to a string and this string can be deserialized to the original tree structure.
+
+The encoded string should be as compact as possible.
+
+Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.
+*/
+
+//注意这个问题是要求你进行序列化和反序列化二叉查找树
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Codec {
+public:
+    
+    
+    //思路一：采用层序遍历的方式进行，借助queue来实现，本质是BFS算法，并且得借助输入、输出流
+    // Encodes a tree to a single string.
+    /*
+    string serialize(TreeNode* root) {
+        if (!root)
+            return "";
+        
+        ostringstream os;         //cpp输出流
+        queue<TreeNode*> q;
+        q.push(root);
+        while (!q.empty()) {
+            TreeNode* node = q.front();
+            q.pop();
+            if (node) {
+                os << node->val << " ";      //如果存在改node，输出值和空格，负责输出#
+                q.push(node->left);
+                q.push(node->right);
+            }
+            else {
+                os << "#";
+            }
+        }
+        
+        return os.str();
+    }
+
+    // Decodes your encoded data to tree.
+    TreeNode* deserialize(string data) {
+        if (data.empty()) 
+            return NULL;
+        
+        istringstream is(data);
+        queue<TreeNode*> q;
+        string val = "";
+        //生成根节点
+        is >> val;
+        TreeNode* root = new TreeNode(stoi(val));
+        TreeNode* cur = root;
+        q.push(cur);
+        while (!q.empty()) {
+            TreeNode* node = q.front();
+            q.pop();
+            //一步步从序列里面读取node信息
+            if (!(is >> val))
+                break;
+            if (val != "#") {
+                cur = new TreeNode(stoi(val));
+                q.push(cur);
+                node->left = cur;
+            }
+            if (!(is >> val))
+                break;
+            if (val != "#") {
+                cur = new TreeNode(stoi(val));
+                q.push(cur);
+                node->right = cur;
+            }
+        }
+        
+        return root;
+    }
+    */
+    
+    
+    
+    //思路二：利用递归的思想
+    string serialize(TreeNode* root) {
+        ostringstream os;
+        serializeHelper(root, os);
+        return os.str();
+    }
+    
+    void serializeHelper(TreeNode* node, ostringstream &os) {
+        if (!node) {
+            os << "# ";       //注意写入的是#还有空格
+        }
+        else {
+            os << node->val << " ";
+            //然后加入左子树和右子树
+            serializeHelper(node->left, os);
+            serializeHelper(node->right, os);
+        }
+    }
+    
+    TreeNode* deserialize(string data) {
+        istringstream is(data);
+        return deserializeHelper(is);
+    }
+    
+    TreeNode* deserializeHelper(istringstream &is) {
+        string val = "";
+        is >> val;
+        if (val == "#") 
+            return NULL;
+        //其他的需要生成新的node
+        TreeNode *node = new TreeNode(stoi(val));
+        node->left = deserializeHelper(is);
+        node->right = deserializeHelper(is);
+        return node;
+    }
+    
+};
+
+// Your Codec object will be instantiated and called as such:
+// Codec codec;
+// codec.deserialize(codec.serialize(root));
diff --git a/Tree/llb/450. Delete Node in a BST.cpp b/Tree/llb/450. Delete Node in a BST.cpp
@@ -0,0 +1,135 @@
+/*
+问题描述：
+
+Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.
+
+Basically, the deletion can be divided into two stages:
+
+Search for a node to remove.
+If the node is found, delete the node.
+Note: Time complexity should be O(height of tree).
+
+Example:
+
+root = [5,3,6,2,4,null,7]
+key = 3
+
+    5
+   / \
+  3   6
+ / \   \
+2   4   7
+
+Given key to delete is 3. So we find the node with value 3 and delete it.
+
+One valid answer is [5,4,6,2,null,null,7], shown in the following BST.
+
+    5
+   / \
+  4   6
+ /     \
+2       7
+
+Another valid answer is [5,2,6,null,4,null,7].
+
+    5
+   / \
+  2   6
+   \   \
+    4   7
+*/
+
+
+/**
+ * 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:
+    
+    /*由于是BST
+    1.该结点无孩子：直接删除
+    2.该节点只有一个孩子：则用该孩子代替被删节点
+    3.左右孩子均有，需要调整后面所有的树节点
+    注：需要考虑左右孩子有孩子的情况
+    难点：删完节点后，还需要是一个二叉搜索树，所以补上的那个节点不一定是其左右孩子节点
+    */
+    
+    
+    /*方法一：递归：
+    步骤：
+    1.先可利用BST的左<根<右的特性找到要被删的节点。
+    2.找到该节点，如果被删节点有一个孩子为空，那么就将另一个不为空的孩子代替即可。
+    3.如果都不为空，那么可以找到左子树最右的节点或者右子树最左的节点代替被删节点均可以。然后用递归删除最左或者最右的节点即可。
+    */
+    TreeNode* deleteNode(TreeNode* root, int key) {
+        if (root == NULL) 
+            return NULL;
+        
+        //找到被删节点
+        if (root->val > key) {
+            root->left = deleteNode(root->left, key);
+        } 
+        else if (root->val < key) {
+            root->right = deleteNode(root->right, key);
+        }
+        else {
+            //如果找到该节点后，只有一个孩子
+            if (!root->left || !root->right) {
+                root = (root->left) ? root->left : root->right;
+            }
+            //左右孩子都有
+            else {
+                //找到该节点右子树的最左孩子节点(左子树的最右孩子节点也可)
+                TreeNode* cur = root->right;
+                while (cur->left) {
+                    cur = cur->left;
+                }
+                //用找到的最左孩子节点，替换被删除的节点(其实只是值的替换，并非真的删除节点)
+                root->val = cur->val;
+                //然后递归来删除右子树中最左的这个点(实际真的删除了)
+                root->right = deleteNode(root->right, cur->val);   //为什么递归，因为有可能这个最左(右)的节点也可能右孩子
+            }
+        }
+        
+        return root;
+    }
+    
+    
+    //方法二：整个都可以使用，而非只是BST
+    /*
+    TreeNode* deleteNode(TreeNode* root, int key) {
+        if (!root) 
+            return NULL;
+        
+        //判断当找到该节点时
+        if (root->val == key) {
+            //这里考虑利用左子树的最右节点代替被删节点
+            if (root->left) {
+                TreeNode* cur = root->left;
+                while(cur->right) {
+                    cur = cur->right;
+                }
+                //找到最右点时，交换值即可（被更改的值，在后续递归中会删除）
+                swap(root->val, cur->val);
+            }
+            else {
+                //如果左子树不存在，直接返回右子树
+                return root->right;
+            }   
+        }
+        
+        //然后循环左右子树
+        root->left = deleteNode(root->left, key);
+        root->right = deleteNode(root->right, key);
+        
+        return root;
+    }
+    */
+    
+};
diff --git a/Tree/llb/98. Validate Binary Search Tree.cpp b/Tree/llb/98. Validate Binary Search Tree.cpp
