Skip to content

Commit 9dccd1e

Browse files
andy2gitandy2git
committed
More solutions
1 parent 328b36a commit 9dccd1e

18 files changed

+564
-3
lines changed

‎Binary_Tree_Level_Order_Traversal_2.cpp

+4-3
Original file line numberDiff line numberDiff line change
@@ -12,20 +12,21 @@ class Solution {
1212
vector<vector<int>> levelOrderBottom(TreeNode *root) {
1313
if(root == nullptr) return vector<vector<int>>();
1414

15-
vector<vector<int>> result;
1615
queue<TreeNode *> p, q;
1716
p.push(root);
1817

18+
vector<vector<int>> result;
1919
vector<int> layer;
2020
TreeNode *t = nullptr;
21+
2122
while(!p.empty()){
2223
t = p.front();
23-
24+
p.pop();
2425
layer.push_back(t->val);
26+
2527
if(t->left) q.push(t->left);
2628
if(t->right) q.push(t->right);
2729

28-
p.pop();
2930
if(p.empty()){
3031
swap(p, q);
3132
result.insert(result.begin(), layer);

‎Binary_Tree_Postorder_Traversal.cpp

+40
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
/**
2+
* Definition for binary tree
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
vector<int> postorderTraversal(TreeNode *root) {
13+
// IMPORTANT: Please reset any member data you declared, as
14+
// the same Solution instance will be reused for each test case.
15+
if(root == nullptr) return {};
16+
17+
stack<TreeNode *> p, q;
18+
p.push(root);
19+
20+
TreeNode *t = nullptr;
21+
while(!p.empty()){
22+
t = p.top();
23+
p.pop();
24+
25+
if(t->left) p.push(t->left);
26+
if(t->right) p.push(t->right);
27+
q.push(t);
28+
}
29+
30+
vector<int> result;
31+
while(!q.empty()){
32+
t = q.top();
33+
q.pop();
34+
result.push_back(t->val);
35+
}
36+
37+
return result;
38+
}
39+
};
40+

‎Container_With_Most_Water.cpp

+46
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
class Solution {
2+
public:
3+
int maxArea(vector<int> &height) {
4+
if(height.empty()) return 0;
5+
6+
int i = 0;
7+
int j = (int)height.size()-1;
8+
int max_area = min(height[i], height[j])*(j-i);
9+
10+
while(i < j){
11+
if(height[i] < height[j]){
12+
i = next_forward(height, i);
13+
if(i < 0) break;
14+
}else{
15+
j = next_backward(height, j);
16+
if(j < 0) break;
17+
}
18+
19+
int t = min(height[i], height[j])*(j-i);
20+
if(t > max_area){
21+
max_area = t;
22+
}
23+
}
24+
25+
return max_area;
26+
}
27+
28+
private:
29+
// (s, ---)
30+
int next_forward(vector<int> &A, int s){
31+
for(int i = s+1; i < A.size(); i++){
32+
if(A[i] > A[s]) return i;
33+
}
34+
35+
return -1;
36+
}
37+
38+
int next_backward(vector<int> &A, int e){
39+
for(int i = e-1; i >= 0; i--){
40+
if(A[i] > A[e]) return i;
41+
}
42+
43+
return -1;
44+
}
45+
46+
};

‎Generate_Parentheses.cpp

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
vector<string> generateParenthesis(int n) {
4+
if(n == 1) return {"()"};
5+
6+
vector<string> result;
7+
string sofar = "(";
8+
9+
parenthesis_helper(result, sofar, 1, 1, 0, 2*n);
10+
return result;
11+
}
12+
private:
13+
void parenthesis_helper(vector<string> &result, string sofar, int k, int l, int r, int m){
14+
if(k == m){
15+
result.push_back(sofar);
16+
return;
17+
}
18+
19+
if(r > l) return;
20+
21+
if(l < m/2) parenthesis_helper(result, sofar + "(", k+1, l+1, r, m);
22+
if(r < m/2) parenthesis_helper(result, sofar + ")", k+1, l, r+1, m);
23+
}
24+
};

‎Gray_Code.cpp

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public:
3+
vector<int> grayCode(int n) {
4+
if(n == 0) return {0};
5+
6+
vector<int> result = {0, 1};
7+
int k = 1;
8+
int add = 1;
9+
int t;
10+
11+
while(k < n){
12+
t = result.size();
13+
add *= 2;
14+
for(int i = t-1; i >= 0; i--){
15+
result.push_back(result[i]+add);
16+
}
17+
k++;
18+
}
19+
20+
return result;
21+
}
22+
};

‎Length_of_Last_Word.cpp

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
class Solution {
2+
public:
3+
int lengthOfLastWord(const char *s) {
4+
int cnt = 0;
5+
6+
while(*s){
7+
while(*s && *s == ' ') s++;
8+
9+
if(*s) cnt = 0;
10+
else return cnt;
11+
12+
while(*s && isalpha(*s)){
13+
s++;
14+
cnt++;
15+
}
16+
}
17+
18+
return cnt;
19+
}
20+
};

‎Maximum_Depth_of_Binary_Tree.cpp

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
/**
2+
* Definition for binary tree
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
int maxDepth(TreeNode *root) {
13+
if(root == nullptr) return 0;
14+
if(root->left == nullptr && root->right == nullptr) return 1;
15+
16+
return max(maxDepth(root->left), maxDepth(root->right))+1;
17+
}
18+
};
19+

‎Pascal_Triangle.cpp

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
public:
3+
vector<vector<int> > generate(int numRows) {
4+
if(numRows <= 0) return vector<vector<int>>();
5+
6+
vector<vector<int>> result = {{1}};
7+
vector<int> layer;
8+
int k = 2;
9+
int t;
10+
11+
while(k <= numRows){
12+
layer.clear();
13+
for(int i = 0; i < k; i++){
14+
15+
if(i > 0) t = result[k-2][i-1];
16+
else t = 0;
17+
18+
if(i < k-1) t += result[k-2][i];
19+
else t += 0;
20+
layer.push_back(t);
21+
}
22+
result.push_back(layer);
23+
k++;
24+
}
25+
26+
return result;
27+
}
28+
};

‎Plus_One.cpp

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public:
3+
vector<int> plusOne(vector<int> &digits) {
4+
int cbit = 1;
5+
vector<int> result(digits);
6+
7+
for(int i = digits.size()-1; i >= 0; i--){
8+
if(digits[i] == 9){
9+
if(cbit == 1){
10+
cbit = 1;
11+
result[i] = 0;
12+
}
13+
}else{
14+
if(cbit == 1){
15+
cbit = 0;
16+
result[i]++;
17+
}
18+
}
19+
}
20+
21+
if(cbit == 1) result.insert(result.begin(), 1);
22+
23+
return result;
24+
}
25+
};

‎Rotate_Image.cpp

+39
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
class Solution {
2+
public:
3+
void rotate(vector<vector<int> > &matrix) {
4+
if(matrix.empty()) return;
5+
6+
fold_dig(matrix);
7+
fold_horiz(matrix);
8+
9+
}
10+
11+
private:
12+
void fold_dig(vector<vector<int>> &M){
13+
int n = (int)M.size();
14+
15+
for(int i = 0; i < n; i++){
16+
for(int j = i+1; j < n; j++){
17+
swap(M[i][j], M[j][i]);
18+
}
19+
}
20+
}
21+
22+
void fold_horiz(vector<vector<int>> &M){
23+
int i = 0;
24+
int j = (int)M.size()-1;
25+
26+
while(i < j){
27+
swap_col(M, i, j);
28+
i++;
29+
j--;
30+
}
31+
}
32+
33+
void swap_col(vector<vector<int>> &M, int i, int j){
34+
for(int k = 0; k < M.size(); k++){
35+
swap(M[k][i], M[k][j]);
36+
}
37+
}
38+
39+
};

‎Search_in_Rotated_Sorted_Array.cpp

+68
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,68 @@
1+
class Solution {
2+
public:
3+
int search(int A[], int n, int target) {
4+
if(n <= 0) return -1;
5+
6+
int l = 0;
7+
int h = n-1;
8+
int m;
9+
10+
while(l <= h){
11+
m = l + (h-l)/2;
12+
13+
if(A[m] == target) return m;
14+
15+
if(A[l] <= A[m]){
16+
if(A[m] < target) l = m+1;
17+
else if(A[m] > target){
18+
if(target > A[l]) h = m-1;
19+
else if(target == A[l]) return l;
20+
else l = m+1;
21+
}
22+
}else{
23+
if(A[m] < target){
24+
if(target < A[h]) {
25+
l = m+1;
26+
h--;
27+
}else if(target == A[h]){
28+
return h;
29+
}else{
30+
h = m-1;
31+
}
32+
}else{
33+
h = m-1;
34+
}
35+
}
36+
}
37+
38+
return -1;
39+
}
40+
};
41+
42+
class Solution {
43+
public:
44+
int search(int A[], int n, int target) {
45+
if(n <= 0) return -1;
46+
47+
int l = 0;
48+
int h = n-1;
49+
int m;
50+
51+
while(l <= h){
52+
m = l + (h-l)/2;
53+
if(A[m] == target) return m;
54+
55+
if(A[l] <= A[m]){ //l and m might point to the same element for [2, 1] case
56+
if(A[l] == target) return l;
57+
if(target < A[m] && target > A[l]) h = m-1;
58+
else l = m+1;
59+
}else if(A[l] > A[m]){
60+
if(A[h] == target) return h;
61+
if(target > A[m] && target < A[h]) l = m+1;
62+
else h = m-1;
63+
}
64+
}
65+
66+
return -1;
67+
}
68+
};

‎Search_in_Rotated_Sorted_Array_2.cpp

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
class Solution {
2+
public:
3+
bool search(int A[], int n, int target) {
4+
if(n <= 0) return false;
5+
6+
int l = 0;
7+
int h = n-1;
8+
int m;
9+
10+
while(l <= h){
11+
m = l + (h-l)/2;
12+
if(A[m] == target) return true;
13+
14+
if(A[l] < A[m]){
15+
if(A[l] == target) return true;
16+
if(target < A[m] && target > A[l]) h = m-1;
17+
else l = m+1;
18+
}else if(A[l] > A[m]){
19+
if(A[h] == target) return true;
20+
if(target > A[m] && target < A[h]) l = m+1;
21+
else h = m-1;
22+
}else{
23+
l++;
24+
}
25+
}
26+
27+
return false;
28+
}
29+
};

0 commit comments

Comments
 (0)