Leetode on Coinidea's Blog

[leetcode_20]Valid Parentheses

Fri, 22 May 2015 01:50:51 +0000

Given a string containing only the characters (){}[], determine whether they are properly matched.
A stack can solve this problem.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 bool IsMatch(char left,char right) {
 if(left == '{' && right == '}' ||
 left == '[' && right == ']' ||
 left == '(' && right == ')') {
 return true;
 }
 else
 return false;
 }
 bool isValid(string s) {
 stack<int> sta;
 for(int i = 0;i < s.length();i++) {
 if(sta.size() == 0 || IsMatch(sta.top(),s[i]) == false) {
 sta.push(s[i]);
 }
 else {
 sta.pop();
 }
 }
 if(sta.size() == 0) {
 return true;
 }
 else
 return false;
 }
};

[leetcode_129] Sum Root to Leaf Numbers

Fri, 22 May 2015 01:49:43 +0000

A binary tree where each node from root to leaf stores a digit from 0 to 9. Calculate the sum of all numbers formed from root to leaf paths. Search from the root to each leaf node, convert the string to a number, and add it to the result.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 int ConvertNumber(string &tmpNumber) {
 int number = 0;
 for(int i = 0;i < tmpNumber.length();i++) {
 number += (tmpNumber[tmpNumber.length() - 1 - i] - '0')*pow(10.0,i);
 }
 return number;
 }
 void AddNextLevel(TreeNode *node,int &sum,string tmpNumber) {
 tmpNumber.push_back(node->val + '0' - 0);
 if(node->left == NULL && node->right == NULL) {
 sum += ConvertNumber(tmpNumber);
 return ;
 }
 if(node->left != NULL) {
 AddNextLevel(node->left,sum,tmpNumber);
 }
 if(node->right != NULL) {
 AddNextLevel(node->right,sum,tmpNumber);
 }
 }
 int sumNumbers(TreeNode *root) {
 int sum = 0;
 if(root == NULL)return sum;
 string tmpNumber = "";
 AddNextLevel(root,sum,tmpNumber);
 return sum;
 }
};

[leetcode_111] Minimum Depth of Binary Tree

Fri, 22 May 2015 01:48:19 +0000

Find the minimum depth of a binary tree, calculated level by level. I used search with pruning. BFS might be faster in terms of time but requires extra space.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution {
public:
 int min;
 void MoveTo(TreeNode *node, int steps) {
 if (node->left == NULL && node->right == NULL) {
 if (steps < min) {
 min = steps;
 }
 return;
 }
 if (node->left != NULL && steps + 1 < min) {
 MoveTo(node->left, steps + 1);
 }
 if (node->right != NULL && steps + 1 < min) {
 MoveTo(node->right, steps + 1);
 }
 }
 int minDepth(TreeNode *root) {
 min = 999999999;
 if (root == NULL)
 return 0;
 MoveTo(root, 1);
 return min;
 }
};

[leetcode_117] Populating Next Right Pointers in Each Node II

Fri, 22 May 2015 01:47:16 +0000

A variation of Populating Next Right Pointers in Each Node:

http://blog.sina.com.cn/s/blog_672f71fc0101ohqp.html
However, it seems like I didn’t use constant space.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


class Solution {
public:
 void connect(TreeLinkNode *root) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int height = -1;
 TreeLinkNode * rootheight = root;
 while(rootheight != NULL)
 {
 height++;
 rootheight = rootheight->left;
 }
 int NumOfNodes = (int)pow(2.0,height+1) - 1;
 TreeLinkNode ** LinkNodeArray = new TreeLinkNode *[1000000];
 int index = 0;
 LinkNodeArray[index++] = root;
 int bottom = 0;
 int top = index;
 while(true)
 {
 if(bottom == top)
 break;
 for(int i = bottom;i < top;i++)
 {
 if(LinkNodeArray[i] == NULL)
 continue;
 if(i == top-1)
 {
 LinkNodeArray[i] ->next = NULL;
 if(LinkNodeArray[i]->left != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->left;
 if(LinkNodeArray[i]->right != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->right;
 }
 else
 {
 LinkNodeArray[i] ->next = LinkNodeArray[i+1];
 if(LinkNodeArray[i]->left != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->left;
 if(LinkNodeArray[i]->right != NULL)
 LinkNodeArray[index++] = LinkNodeArray[i]->right;
 }
 }
 bottom = top;
 top = index;
 }
 }
};

[leetcode_81] Search in Rotated Sorted Array II

Fri, 22 May 2015 01:45:49 +0000

A variation of the previous Search in Rotated Sorted Array problem.
Original post
This time, the array allows duplicates. I modified the code’s conditional logic accordingly.
Still O(log n).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


class Solution {
public:
 bool searchStep(int A[],int target,int left,int right)
 {
 if(left > right)
 return false;
 int mid = (left+right)/2;
 if(A[mid] == target)
 return true;
 else
 if(A[mid] > target)
 {
 if(A[right] > A[left])
 return searchStep(A,target,left,mid-1);
 else
 return searchStep(A,target,left,mid-1) || searchStep(A,target,mid+1,right);
 }
 else
 {
 if(A[right] > A[left])
 return searchStep(A,target,mid+1,right);
 else
 return searchStep(A,target,mid+1,right) || searchStep(A,target,left,mid-1);
 }
 }
 bool search(int A[], int n, int target)
 {
 int left = 0;
 int right = n-1;
 return searchStep(A,target,left,right);
 }
};

[leetcode_33] Search in Rotated Sorted Array

Fri, 22 May 2015 01:44:32 +0000

Given a sorted array that has been rotated. For example: 0 1 2 3 4 5 6 7 8 9 after rotation becomes: 7 8 9 0 1 2 3 4 5 6
Given a target, return its index if it exists in the array, otherwise return -1.
Obviously, anyone can think of an O(n) approach.
Can we do better? O(log n)? Binary search? Just modify binary search a bit:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 int ans;
 void searchStep(int A[],int target,int left,int right)
 {
 if(left > right)
 return;
 int mid = (left+right)/2;
 if(A[mid] == target)
 {
 ans = mid;
 return;
 }
 else
 {
 if(A[mid] > target)
 {
 if(A[right] > A[left])
 {
 searchStep(A,target,left,mid-1);
 }
 else
 {
 searchStep(A,target,left,mid-1);
 searchStep(A,target,mid+1,right);
 }
 }
 else
 {
 if(A[right] > A[left])
 {
 searchStep(A,target,mid+1,right);
 }
 else
 {
 searchStep(A,target,mid+1,right);
 searchStep(A,target,left,mid-1);
 }
 }
 }
 }
 int search(int A[], int n, int target)
 {
 int left = 0;
 int right = n-1;
 ans = -1;
 searchStep(A,target,left,right);
 return ans;
 }
};

[leetcode_77] Combinations

Fri, 22 May 2015 01:43:16 +0000

A simple search problem, though the problem statement wasn’t very clear (or maybe my English isn’t great). Basically, given n, the universal set is 1, 2, 3…n. Choose k elements to form subsets, and enumerate all such subsets.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 void combineStep(int n, int step, int k, vector<int>& item, vector<vector<int>>& ans, int count)
 {
 if(step > n+1)
 return;
 if(count == k)
 {
 ans.push_back(item);
 return ;
 }
 else
 {
 item.push_back(step);
 combineStep(n, step+1, k, item, ans, count+1);
 item.pop_back();
 combineStep(n, step+1, k, item, ans, count);
 }
 }
 vector<vector<int>> combine(int n, int k) {
 vector<vector<int>> ans;
 ans.clear();
 vector<int> item;
 item.clear();
 combineStep(n, 1, k, item, ans, 0);
 return ans;
 }
};

[leetcode_19] Remove Nth Node From End of List

Fri, 22 May 2015 01:40:35 +0000

Given a singly linked list, remove the nth node from the end. Try to do it in one pass.
Use two pointers with a gap of exactly n between them. When the second pointer reaches NULL, remove the node at the first pointer.
Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 ListNode *removeNthFromEnd(ListNode *head, int n) {
 ListNode *before = NULL;
 ListNode *p1 = head;
 ListNode *p2 = head;
 if(n <= 0) return head;
 for(int i = 0; i < n; i++) {
 p2 = p2->next;
 }
 while(p2 != NULL) {
 p2 = p2->next;
 before = p1;
 p1 = p1->next;
 }
 if(before == NULL) {
 return head->next;
 } else {
 before->next = p1->next;
 return head;
 }
 }
};

[leetcode_80] Remove Duplicates from Sorted Array II

Fri, 22 May 2015 01:39:17 +0000

A simulation problem, but it was quite tedious to implement.
AC on the first try:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


class Solution {
public:
 int removeDuplicates(int A[], int n) {
 if(n == 0)
 return n;
 int now;
 int count = 0;
 int len = n;
 for(int i = 0; i < len; i++) {
 if(count == 0 || now != A[i]) {
 count = 1;
 now = A[i];
 continue;
 }
 if(A[i] == now) {
 if(count == 2) {
 int dis = 0;
 int tmp = A[i];
 for(int j = i+1; j < len; j++) {
 if(tmp == A[j]) {
 dis++;
 } else {
 A[j-1-dis] = A[j];
 }
 }
 len -= 1 + dis;
 i--;
 } else {
 count++;
 }
 }
 }
 return len;
 }
};

[leetcode_73] Set Matrix Zeroes

Fri, 22 May 2015 01:38:02 +0000

Given an mn matrix, set the entire row and column to 0 for every element that is 0.
The simplest approach is to use an mn matrix to record positions, then set accordingly.
An even simpler approach: use an m+n array to record which rows and columns need to be zeroed.
An even simpler constant-space approach — I thought of one, but it has some issues. Still working on it. For now, here’s the m+n solution.
AC on the first try.
Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


class Solution {
 public:
 void setRZeros(vector<vector<int> > &matrix,int x)
 {
 int m = matrix.size();
 int n = matrix[0].size();
 for(int i = 0;i < n;i++)
 {
 matrix[x][i] = 0;
 }
 }
 void setCZeros(vector<vector<int> > &matrix,int y)
 {
 int m = matrix.size();
 int n = matrix[0].size();
 for(int i = 0;i < m;i++)
 {
 matrix[i][y] = 0;
 }
 }
 void setZeroes(vector<vector<int> > &matrix) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int m = matrix.size();
 int n = matrix[0].size();
 int *R = new int[m];
 int *C = new int[n];
 memset(R,0,m*sizeof(int));
 memset(C,0,n*sizeof(int));
 for(int i = 0;i < m;i++)
 {
 for(int j = 0;j < n;j++)
 {
 if(matrix[i][j] == 0)
 {
 R[i] = 1;
 C[j] = 1;
 }
 }
 }
 for(int i = 0;i < m;i++)
 {
 if(R[i])
 setRZeros(matrix,i);
 }
 for(int i = 0;i < n;i++)
 {
 if(C[i])
 setCZeros(matrix,i);
 }
 }
};

[leetcode_48] Rotate Image

Fri, 22 May 2015 01:14:33 +0000

Rotate an n*n matrix 90 degrees clockwise. Additionally, can you do it in-place without allocating extra space?
AC on the first try. Each position’s rotation only affects 4 positions in the matrix. Just use a single tmp variable and it’s done.
Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 void MoveStep(vector<vector<int>> &matrix,int i,int j,int n)
 {
 int x1 = i;
 int y1 = j;

 int x2 = y1;
 int y2 = n - x1;

 int x3 = n - x1;
 int y3 = n - y1;

 int x4 = n - y1;
 int y4 = x1;

 int tmp = matrix[x4][y4];
 matrix[x4][y4] = matrix[x3][y3];
 matrix[x3][y3] = matrix[x2][y2];
 matrix[x2][y2] = matrix[x1][y1];
 matrix[x1][y1] = tmp;
 }

 void rotate(vector<vector<int>> &matrix) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int length = matrix.size();
 int n = length / 2;
 if(length % 2 == 0)
 {
 for(int i = 0; i < n; i++)
 {
 for(int j = 0; j < n; j++)
 {
 MoveStep(matrix, i, j, length-1);
 }
 }
 }
 else
 {
 for(int i = 0; i < n; i++)
 {
 for(int j = 0; j <= n; j++)
 {
 MoveStep(matrix, i, j, length-1);
 }
 }
 }
 }
};

[leetcode_137] Single Number II

Thu, 21 May 2015 08:25:03 +0000

Given n numbers where every number appears three times except one which appears only once, find that single number (in linear time and space).
I’m sure everyone knows the two-number version — just use XOR.
Initially I used a map to solve it, but that didn’t feel like it met the problem’s intent. After reading others’ approaches, I realized it’s a variation of the same idea. I feel like I need to improve at generalizing solutions and analyzing problems.
The purpose of XOR is to count the number of 1s at each bit position, and reset to zero when the count reaches two.
Similarly, for three numbers, we reset to zero when the count reaches three.
Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class Solution {
public:
 int singleNumber(int A[], int n) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 int now = A[0];
 int one = now;
 int two = 0;
 int three = 0;
 for(int i = 1; i < n; i++)
 {
 int input = A[i];
 int in1 = one & input;
 one = one ^ input;
 int in2 = two & in1;
 two = two ^ in1;

 one = one ^ in2;
 }
 return one ^ two;
 }
};

[leetcode_22] Generate Parentheses

Thu, 21 May 2015 08:23:53 +0000

Given a number n, generate all combinations of n pairs of parentheses.
For example, n=2: (()), ()()
This problem can be solved by backtracking through all possible cases:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 vector<string> ans;
 void genStep(string &item,int n,int countLeft,int countRight)
 {
 if(countLeft == n && countRight == n)
 {
 ans.push_back(item);
 return;
 }
 if(countLeft < n)
 {
 countLeft++;
 item.insert(item.length(),"(");
 genStep(item,n,countLeft,countRight);
 countLeft--;
 item = item.erase(item.length()-1,1);
 }
 if(countRight < n && countLeft > countRight)
 {
 countRight++;
 item.insert(item.length(),")");
 genStep(item,n,countLeft,countRight);
 countRight--;
 item = item.erase(item.length()-1,1);
 }
 }
 vector<string> generateParenthesis(int n) {
 ans.clear();
 if(n == 0)return ans;
 int countLeft = 1;
 int countRight = 0;
 string item = "(";
 genStep(item,n,countLeft,countRight);
 return ans;
 }
};

[leetcode_89] Gray Code

Thu, 21 May 2015 08:22:35 +0000

This problem was frustrating — no special judge allowed. So I initially wrote a solution that got WA. They said sorry, no special judge, so I adjusted based on the sample output.
The idea is:

1
Prepend (or append) (0, 1), (1, 0), (0, 1), (1, 0), (0, 1), (1, 0)… to each number in the sequence [as shown in the sample]. Each number generates two new numbers. This ensures only one bit changes at a time, because the numbers from the previous round follow the pattern. So there won’t be any issues.
Here are both versions of the code:
WA code (I believe it should pass):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class Solution {
public:
 vector<int> grayCode(int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<int> seq;
 seq.clear();
 if(n == 0)
 {
 seq.push_back(0);
 return seq;
 }
 for(int i = 0;i < n;i++)
 {
 if(i == 0)
 {
 seq.push_back(0);
 seq.push_back(1);
 }
 else
 {
 vector<int>seq_copy;
 seq_copy.clear();
 int increase = (int)pow(2.0,i);
 int state = 0;
 for(int j = 0;j < seq.size();j++)
 {
 if(state == 0)
 {
 seq_copy.push_back(seq[j] + 0);
 seq_copy.push_back(seq[j] + increase);
 state = 1;
 }
 else
 if(state == 1)
 {
 seq_copy.push_back(seq[j] + increase);
 seq_copy.push_back(seq[j] + 0);
 state = 0;
 }
 }
 seq.clear();
 for(int j = 0;j < seq_copy.size();j++)
 {
 seq.push_back(seq_copy[j]);
 }
 }
 }
 return seq;
 }
};

AC code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


class Solution {
public:
 vector<int> grayCode(int n) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 vector<int> seq;
 seq.clear();
 if(n == 0)
 {
 seq.push_back(0);
 return seq;
 }
 for(int i = 0;i < n;i++)
 {
 if(i == 0)
 {
 seq.push_back(0);
 seq.push_back(1);
 }
 else
 {
 vector<int>seq_copy;
 seq_copy.clear();
 int state = 0;
 for(int j = 0;j < seq.size();j++)
 {
 if(state == 0)
 {
 seq_copy.push_back((seq[j]<<1) + 0);
 seq_copy.push_back((seq[j]<<1)+1);
 state = 1;
 }
 else
 if(state == 1)
 {
 seq_copy.push_back((seq[j]<<1)+1);
 seq_copy.push_back((seq[j]<<1) + 0);
 state = 0;
 }
 }
 seq.clear();
 for(int j = 0;j < seq_copy.size();j++)
 {
 seq.push_back(seq_copy[j]);
 }
 }
 }
 return seq;
 }
};

[leetcode_24] Swap Nodes in Pairs

Thu, 21 May 2015 08:20:37 +0000

This problem is essentially a simulation problem — swap ListNode nodes in pairs, based on nodes rather than values. It’s fairly simple, but I struggled with it for quite a while. Got AC on the first try, but I feel like my code never looks elegant and lacks reusability. My logic needs improvement. Still need to keep working hard.
Here is the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
 ListNode *swapPairsStep(ListNode *head, int PairsNum) {
 ListNode *now = head;
 ListNode *before;
 for (int i = 0; i < PairsNum; i++) {
 now = now->next;
 before = now;
 now = now->next;
 }
 if (PairsNum == 0) {
 ListNode *tmp = now->next;
 now->next = now->next->next;
 tmp->next = now;
 return tmp;
 } else {
 ListNode *tmp = now->next;
 now->next = now->next->next;
 tmp->next = now;
 before->next = tmp;
 }
 return head;
 }

 bool IsCheck(ListNode *head, int PairsNum) {
 ListNode *now = head;
 for (int i = 0; i < PairsNum; i++) {
 now = now->next;
 now = now->next;
 }
 if (now != NULL && now->next != NULL) {
 return true;
 } else {
 return false;
 }
 }

 ListNode *swapPairs(ListNode *head) {
 // Note: The Solution object is instantiated only once and is reused by each test case.
 int num = 0;
 while (IsCheck(head, num)) {
 head = swapPairsStep(head, num);
 num++;
 }
 return head;
 }
};

[leetcode_108]Convert Sorted Array to Binary Search Tree

Thu, 21 May 2015 08:17:25 +0000

Watch out for out-of-bounds issues when the input is empty.
Binary split each time – since the array is sorted, use the midpoint as the root.
Apply the same logic recursively to subtrees.
Code below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class Solution {
public:
 TreeNode *sortedArrayToBST(vector<int> &num) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 if(num.size() <= 0)
 return NULL;
 int size = num.size()-1;
 int mid = size / 2;
 TreeNode * root = new TreeNode(num[mid]);
 TreeNode * left = GetNode(num,0,mid-1);
 TreeNode * right = GetNode(num,mid+1,size);
 root->left = left;
 root->right = right;
 return root;
 }
 TreeNode *GetNode(vector<int> &num,int a,int b)
 {
 if(a > b)
 {
 return NULL;
 }
 int mid = a + (b - a) / 2;
 TreeNode * node = new TreeNode(num[mid]);
 TreeNode * left = GetNode(num,a,mid-1);
 TreeNode * right = GetNode(num,mid+1,b);
 node->left = left;
 node->right = right;
 return node;
 }
};

[leetcode_110]Balanced Binary Tree

Thu, 21 May 2015 08:16:19 +0000

Determine whether a tree is a balanced binary tree.
AC on the first try. Code below (I originally thought it would TLE):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution {
public:
 bool ans;
 bool isBalanced(TreeNode *root) {
 // IMPORTANT: Please reset any member data you declared, as
 // the same Solution instance will be reused for each test case.
 ans = true;
 if(root == NULL)
 return ans;
 Calc(root);
 return ans;
 }
 int Calc(TreeNode *node)
 {
 if(node == NULL)
 return 0;
 int left = Calc(node->left) + 1;
 int right = Calc(node->right) + 1;
 if(abs(left - right) > 1)
 {
 ans = false;
 }
 if(left > right)
 return left;
 else
 return right;
 }
};