From 5c4ce3326454fa0a7150d3d5b2fce2ad60065387 Mon Sep 17 00:00:00 2001 From: xliu45 Date: Fri, 4 Mar 2016 21:06:58 -0600 Subject: [PATCH 1/8] C++/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp --- ...ee_from_Preorder_and_Inorder_Traversal.cpp | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp diff --git a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp new file mode 100644 index 00000000..2f847baf --- /dev/null +++ b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp @@ -0,0 +1,60 @@ +/* +Given preorder and inorder traversal of a tree, construct the binary tree. + +Note: +You may assume that duplicates do not exist in the tree. + +Tag: +Tree, Array, Depth-first-search + +Author: +Xinyu Liu +*/ + +#include +#include +using namespace std; + + +// 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: + TreeNode* buildTree(vector& preorder, vector& inorder) { + return subtree(preorder, 0, preorder.size() - 1 , inorder, 0, preorder.size() - 1); + } + TreeNode* subtree(vector& preorder, int begin1, int end1, vector& inorder, int begin2, int end2){ + int i; + if(end1 < begin1) + return NULL; + if(end1 == begin1) + return new TreeNode(preorder.at(begin1)); + + TreeNode* root = new TreeNode(preorder.at(begin1)); + for(i = begin2; i < end2; i++){ + if(inorder.at(i) == root->val) + break; + } + int left_length = i - begin2; + root->left = subtree(preorder, begin1 + 1, begin1 + left_length, inorder, begin2, begin2 + left_length - 1); + root->right = subtree(preorder, begin1 + left_length + 1, end1, inorder, begin2 + left_length + 1, end2); + return root; + } +}; + +void main(){ + + int pre[] = {1,2,3,4}; + vector preorder(pre, pre + sizeof(pre) / sizeof(int)); + int in[] = {2,1,4,3}; + vector inorder(in, in + sizeof(in) / sizeof(int)); + Solution sol; + TreeNode* root = sol.buildTree(preorder, inorder); + +} From 7fd10325cb7a3e91a4dc91c8ea64b2d1002a6f99 Mon Sep 17 00:00:00 2001 From: xliu45 Date: Fri, 4 Mar 2016 21:08:04 -0600 Subject: [PATCH 2/8] Update 105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp --- ...Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp index 2f847baf..32c886d9 100644 --- a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp +++ b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp @@ -1,3 +1,4 @@ +// 105. Construct Binary Tree from Preorder and Inorder Traversal /* Given preorder and inorder traversal of a tree, construct the binary tree. From e350616b6440ad7dc58fa3bc794c8f1d2791d4eb Mon Sep 17 00:00:00 2001 From: xliu45 Date: Fri, 4 Mar 2016 21:08:48 -0600 Subject: [PATCH 3/8] Update 105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp --- ...t_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp index 32c886d9..e556204e 100644 --- a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp +++ b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp @@ -2,14 +2,11 @@ /* Given preorder and inorder traversal of a tree, construct the binary tree. -Note: -You may assume that duplicates do not exist in the tree. +Note: You may assume that duplicates do not exist in the tree. -Tag: -Tree, Array, Depth-first-search +Tag: Tree, Array, Depth-first-search -Author: -Xinyu Liu +Author: Xinyu Liu */ #include From ab20f1e7382265540237e436f743375939b81fd1 Mon Sep 17 00:00:00 2001 From: xliu45 Date: Fri, 4 Mar 2016 21:17:35 -0600 Subject: [PATCH 4/8] Update 105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp --- ...ee_from_Preorder_and_Inorder_Traversal.cpp | 58 +++++++++---------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp index e556204e..cb9109ae 100644 --- a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp +++ b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp @@ -16,43 +16,43 @@ using namespace std; // Definition for a binary tree node. struct TreeNode { - int val; - TreeNode *left; - TreeNode *right; - TreeNode(int x) : val(x), left(NULL), right(NULL) {} + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; class Solution { public: - TreeNode* buildTree(vector& preorder, vector& inorder) { - return subtree(preorder, 0, preorder.size() - 1 , inorder, 0, preorder.size() - 1); - } - TreeNode* subtree(vector& preorder, int begin1, int end1, vector& inorder, int begin2, int end2){ - int i; - if(end1 < begin1) - return NULL; - if(end1 == begin1) - return new TreeNode(preorder.at(begin1)); - - TreeNode* root = new TreeNode(preorder.at(begin1)); - for(i = begin2; i < end2; i++){ - if(inorder.at(i) == root->val) - break; - } - int left_length = i - begin2; - root->left = subtree(preorder, begin1 + 1, begin1 + left_length, inorder, begin2, begin2 + left_length - 1); - root->right = subtree(preorder, begin1 + left_length + 1, end1, inorder, begin2 + left_length + 1, end2); - return root; + TreeNode* buildTree(vector& preorder, vector& inorder) { + return subtree(preorder, 0, preorder.size() - 1 , inorder, 0, preorder.size() - 1); + } + TreeNode* subtree(vector& preorder, int begin1, int end1, vector& inorder, int begin2, int end2){ + int i; + if(end1 < begin1) + return NULL; + if(end1 == begin1) + return new TreeNode(preorder.at(begin1)); + + TreeNode* root = new TreeNode(preorder.at(begin1)); + for(i = begin2; i < end2; i++){ + if(inorder.at(i) == root->val) + break; } + int left_length = i - begin2; + root->left = subtree(preorder, begin1 + 1, begin1 + left_length, inorder, begin2, begin2 + left_length - 1); + root->right = subtree(preorder, begin1 + left_length + 1, end1, inorder, begin2 + left_length + 1, end2); + return root; + } }; void main(){ - int pre[] = {1,2,3,4}; - vector preorder(pre, pre + sizeof(pre) / sizeof(int)); - int in[] = {2,1,4,3}; - vector inorder(in, in + sizeof(in) / sizeof(int)); - Solution sol; - TreeNode* root = sol.buildTree(preorder, inorder); + int pre[] = {1,2,3,4}; + vector preorder(pre, pre + sizeof(pre) / sizeof(int)); + int in[] = {2,1,4,3}; + vector inorder(in, in + sizeof(in) / sizeof(int)); + Solution sol; + TreeNode* root = sol.buildTree(preorder, inorder); } From c67d9af05684759453c7300098d9cb71beccac5b Mon Sep 17 00:00:00 2001 From: xliu45 Date: Fri, 4 Mar 2016 21:37:56 -0600 Subject: [PATCH 5/8] C++/162_Find_Peak_Element.cpp --- C/162_Find_Peak_Element.cpp | 53 +++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 C/162_Find_Peak_Element.cpp diff --git a/C/162_Find_Peak_Element.cpp b/C/162_Find_Peak_Element.cpp new file mode 100644 index 00000000..c8ef04ff --- /dev/null +++ b/C/162_Find_Peak_Element.cpp @@ -0,0 +1,53 @@ +//162. Find Peak Element +/* +A peak element is an element that is greater than its neighbors. +Given an input array where num[i] ≠ num[i+1], find a peak element and return its index. +The array may contain multiple peaks, in that case return the index to any one of the peaks is fine. +You may imagine that num[-1] = num[n] = -∞. + +Example: +in array [1, 2, 3, 1], 3 is a peak element and your function should return the index number 2. + +Tag: Array, Binary Search + +Author: Xinyu Liu +*/ + +#include +#include +using namespace std; + +class Solution { + +public: + int findPeakElement(vector& nums) { + int sz = nums.size(); + if (sz == 1) + return 0; + if (nums.at(0) > nums.at(1)) + return 0; + if (nums.at(sz - 1) > nums.at(sz - 2)) + return sz - 1; + + for(int i = 1; i < nums.size(); i++) + { + if (nums.at(i - 1) < nums.at(i) & nums.at(i) > nums.at(i + 1)) + return i; + } + return -1; + } +}; + +void main(int argc, char ** argv){ + + // Initialize vector + int myints[] = {1, 2, 3, 4, 3}; + int index; + std::vector test (myints, myints + sizeof(myints) / sizeof(int) ); + + Solution sol; + index = sol.findPeakElement (test); + + printf("%i \n",index); + +} From 1e9807f50f50650d5f71a44810a31ac8750feb5c Mon Sep 17 00:00:00 2001 From: xliu45 Date: Fri, 4 Mar 2016 21:51:09 -0600 Subject: [PATCH 6/8] Update 105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp --- ...ct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp index cb9109ae..66c9d106 100644 --- a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp +++ b/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp @@ -39,10 +39,10 @@ class Solution { if(inorder.at(i) == root->val) break; } - int left_length = i - begin2; - root->left = subtree(preorder, begin1 + 1, begin1 + left_length, inorder, begin2, begin2 + left_length - 1); - root->right = subtree(preorder, begin1 + left_length + 1, end1, inorder, begin2 + left_length + 1, end2); - return root; + int left_length = i - begin2; + root->left = subtree(preorder, begin1 + 1, begin1 + left_length, inorder, begin2, begin2 + left_length - 1); + root->right = subtree(preorder, begin1 + left_length + 1, end1, inorder, begin2 + left_length + 1, end2); + return root; } }; From 4c090220d26bca9dfcb079623d663dfa96792c6d Mon Sep 17 00:00:00 2001 From: xliu45 Date: Sat, 5 Mar 2016 13:56:17 -0600 Subject: [PATCH 7/8] path change --- ...struct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp | 0 {C => C++}/162_Find_Peak_Element.cpp | 4 ++-- 2 files changed, 2 insertions(+), 2 deletions(-) rename {C => C++}/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp (100%) rename {C => C++}/162_Find_Peak_Element.cpp (94%) diff --git a/C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp b/C++/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp similarity index 100% rename from C/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp rename to C++/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp diff --git a/C/162_Find_Peak_Element.cpp b/C++/162_Find_Peak_Element.cpp similarity index 94% rename from C/162_Find_Peak_Element.cpp rename to C++/162_Find_Peak_Element.cpp index c8ef04ff..642dc13b 100644 --- a/C/162_Find_Peak_Element.cpp +++ b/C++/162_Find_Peak_Element.cpp @@ -29,10 +29,10 @@ class Solution { if (nums.at(sz - 1) > nums.at(sz - 2)) return sz - 1; - for(int i = 1; i < nums.size(); i++) + for(int i = 1; i < nums.size() - 1; i++) { if (nums.at(i - 1) < nums.at(i) & nums.at(i) > nums.at(i + 1)) - return i; + return i; } return -1; } From 7d966244b70afee5ff71f803fda7c02e9afbcef2 Mon Sep 17 00:00:00 2001 From: xliu45 Date: Sat, 5 Mar 2016 14:15:47 -0600 Subject: [PATCH 8/8] no message --- C++/001_Two_Sum.cpp | 71 ------------------- ...ee_from_Preorder_and_Inorder_Traversal.cpp | 32 ++++----- C++/124_Binary_Tree_Maximum_Path_Sum.cpp | 68 ------------------ C++/162_Find_Peak_Element.cpp | 53 -------------- 4 files changed, 16 insertions(+), 208 deletions(-) delete mode 100644 C++/001_Two_Sum.cpp delete mode 100644 C++/124_Binary_Tree_Maximum_Path_Sum.cpp delete mode 100644 C++/162_Find_Peak_Element.cpp diff --git a/C++/001_Two_Sum.cpp b/C++/001_Two_Sum.cpp deleted file mode 100644 index 40f0e1af..00000000 --- a/C++/001_Two_Sum.cpp +++ /dev/null @@ -1,71 +0,0 @@ -/* - *Given an array of integers, return indices of the two numbers such that they add up to a specific target. - *You may assume that each input would have exactly one solution. - - *Example: - *Given nums = [2, 7, 11, 15], target = 9, - *Because nums[0] + nums[1] = 2 + 7 = 9, - *return [0, 1]. - - *UPDATE (2016/2/13): - *The return format had been changed to zero-based indices. Please read the above updated description carefully - - *Tag: Array, Hash Table - - *Author: Linsen Wu -*/ - -#include "stdafx.h" -#include "iostream" -#include -#include - -using namespace std; - -class Solution { -public: - vector twoSum(vector &numbers, int target) { - vector indexResults; - unordered_map index_map; - unordered_map::iterator it; - for (int i=0; isecond); - indexResults.push_back(i); - return indexResults; - } else { - index_map[numbers[i]] = i; - } - } - return indexResults; - } -}; - -/* -Save the numbers into an unordered map when searching -Time: O(n) -Space: O(n) -*/ - -int _tmain(int argc, _TCHAR* argv[]) -{ - vector input, output; - input.push_back(-1); - input.push_back(7); - input.push_back(11); - input.push_back(15); - - Solution _solution; - output = _solution.twoSum(input, 6); - - for(vector::iterator iterator = output.begin(); iterator != output.end(); iterator++) - cout<<((*iterator))<& preorder, int begin1, int end1, vector& inorder, int begin2, int end2){ - int i; - if(end1 < begin1) - return NULL; - if(end1 == begin1) - return new TreeNode(preorder.at(begin1)); - - TreeNode* root = new TreeNode(preorder.at(begin1)); - for(i = begin2; i < end2; i++){ - if(inorder.at(i) == root->val) - break; - } - int left_length = i - begin2; - root->left = subtree(preorder, begin1 + 1, begin1 + left_length, inorder, begin2, begin2 + left_length - 1); - root->right = subtree(preorder, begin1 + left_length + 1, end1, inorder, begin2 + left_length + 1, end2); - return root; + int i; + if(end1 < begin1) + return NULL; + if(end1 == begin1) + return new TreeNode(preorder.at(begin1)); + + TreeNode* root = new TreeNode(preorder.at(begin1)); + for(i = begin2; i < end2; i++){ + if(inorder.at(i) == root->val) + break; + } + int left_length = i - begin2; + root->left = subtree(preorder, begin1 + 1, begin1 + left_length, inorder, begin2, begin2 + left_length - 1); + root->right = subtree(preorder, begin1 + left_length + 1, end1, inorder, begin2 + left_length + 1, end2); + return root; } }; void main(){ - + int pre[] = {1,2,3,4}; vector preorder(pre, pre + sizeof(pre) / sizeof(int)); int in[] = {2,1,4,3}; diff --git a/C++/124_Binary_Tree_Maximum_Path_Sum.cpp b/C++/124_Binary_Tree_Maximum_Path_Sum.cpp deleted file mode 100644 index 5fa49b26..00000000 --- a/C++/124_Binary_Tree_Maximum_Path_Sum.cpp +++ /dev/null @@ -1,68 +0,0 @@ -// 124. Binary Tree Maximum Path Sum -/** - * Given a binary tree, find the maximum path sum. - * - * For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path does not need to go through the root. - * - * For example: - * Given the below binary tree, - * - * 1 - * / \ - * 2 3 - * Return 6. - * - * Tags: Tree, Depth-first Search - * - * Author: Kuang Qin - */ - -#include "stdafx.h" -#include - -using namespace std; - -/** - * 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 { - int curMax; - -public: - int maxPathSum(TreeNode* root) { - curMax = INT_MIN; - dfs(root); - return curMax; - } - -// if we look at each individual nodes, there are only 3 possiblities: -// a) Left branch: root->val + left -// b) Right branch: root->val + right -// c) Both branches: root->val + left + right -// -// a) or b): it can be accumulated between different nodes, so we use them as the return value in the recursion -// c): it can be only a local maximum, so we compare it to the global maximum and keep whichever is larger - - int dfs(TreeNode* root) { - if (!root) return 0; - - int left = max(dfs(root->left), 0); // if left child val < 0, keep only the parent node value - int right = max(dfs(root->right), 0); // if right child val < 0, keep only the parent node value - curMax = max(curMax, root->val + left + right); // compare the global max to possible local max - - return root->val + max(left, right); // choose whichever is larger - } -}; - -int _tmain(int argc, _TCHAR* argv[]) -{ - return 0; -} - diff --git a/C++/162_Find_Peak_Element.cpp b/C++/162_Find_Peak_Element.cpp deleted file mode 100644 index 642dc13b..00000000 --- a/C++/162_Find_Peak_Element.cpp +++ /dev/null @@ -1,53 +0,0 @@ -//162. Find Peak Element -/* -A peak element is an element that is greater than its neighbors. -Given an input array where num[i] ≠ num[i+1], find a peak element and return its index. -The array may contain multiple peaks, in that case return the index to any one of the peaks is fine. -You may imagine that num[-1] = num[n] = -∞. - -Example: -in array [1, 2, 3, 1], 3 is a peak element and your function should return the index number 2. - -Tag: Array, Binary Search - -Author: Xinyu Liu -*/ - -#include -#include -using namespace std; - -class Solution { - -public: - int findPeakElement(vector& nums) { - int sz = nums.size(); - if (sz == 1) - return 0; - if (nums.at(0) > nums.at(1)) - return 0; - if (nums.at(sz - 1) > nums.at(sz - 2)) - return sz - 1; - - for(int i = 1; i < nums.size() - 1; i++) - { - if (nums.at(i - 1) < nums.at(i) & nums.at(i) > nums.at(i + 1)) - return i; - } - return -1; - } -}; - -void main(int argc, char ** argv){ - - // Initialize vector - int myints[] = {1, 2, 3, 4, 3}; - int index; - std::vector test (myints, myints + sizeof(myints) / sizeof(int) ); - - Solution sol; - index = sol.findPeakElement (test); - - printf("%i \n",index); - -}