Leetode on Coinidea的博客

[leetcode_20]Valid Parentheses

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

给定一个字符串，里面只有(){}[]这六种字符，判断，是否它们能够匹配。
栈即可解决该问题。

 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

二叉树从根开始每个结点存放一个0~9的数字，计算从根开始到叶节点生成的所有数字之和。从根开始搜索，到一个叶节点，将string转换加到结果里面就行。

 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

计算二叉树的最短路径，一层一层的算。我用的应该算是搜索加剪枝，但是如果有宽度搜索，或许时间更快，但是需要额外的空间。

 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

Populating Next Right Pointers in Each Node的变形：

http://blog.sina.com.cn/s/blog_672f71fc0101ohqp.html
但是貌似自己没有使用常数空间

 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

leetcode_60题目的变形
原文链接
这次，array允许重复的。我适当改了下代码判断的情况。
仍然是o(logn)

 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

给定一个sorted 的array但是需要做个调转：比如： 0 1 2 3 4 5 6 7 8 9 某个调转之后：7 8 9 0 1 2 3 4 5 6
输入target，如果array中存在target返回下标，否则，返回-1。
欧克，傻瓜都能想到o(n)的方法，
有没有更快的？o(logn)?二分？二分查找变形一下就行：

 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

简单搜索题，但是题目交代不是很清楚，也可能是自己的英文不大好，就是说给n, 全集为1, 2, 3…n。从里面选k个组成子集，列举所有子集。

 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

给一个单向链表，输入一个n，删掉从后往前第n个元素。尽可能一次遍历单链表。
两个指针，使他们的差距刚好为n, 当后面一个刚好指向NULL的时候，删掉前一个即可。
附上代码：

 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

模拟题，但是做起来好费劲啊。
一次AC:

 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

给一个m*n矩阵，将该矩阵中出现0元素的位置的行列均置为0。
最简单的方法，开一个m*n的矩阵记录，再设置就行了。
更简单的是：开一个m+n的矩阵记录行列就可以了。
更更简单的常数空间的方法，我想了一种，有点问题，正在琢磨，先把m+n的解法贴出来吧。
一次AC。
附上代码：

 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

将一个n*n的矩阵顺时针旋转90度，额外地，能不能原地旋转，就是不开辟额外的空间。
一次AC, 每个位置上的旋转只会影响4个位置上的数组，开一个tmp，搞定。
附上代码：

 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

给出 n 个数，里面每个数字重复 3 次，只有一个数字只出现一次，求该数字 [线性时间和空间]
相信两个数的大家都会，异或就行。
其实最开始用 map 过，觉得不符合题意，看了别人的思路，知道了，其实就是题目的变形，感觉不会举一反三，而且对问题的分析能力不够。
异或的目的就是计数每个位置出现 1 的个数，如果有两次就清零。
同理，3 个数我就出现 3 次清零。
附上代码：

 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

给定数n，生成所有的n个括号的情况。
比如n=2:(()),()()
这个题，回溯搜索所有情况即可：

 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

这个题，我很无奈，不能special judge。好吧开始写了一个代码 WA，人说 sorry 不能sp，于是按照样例改了改。
思想就是

1
在序列中的每个数前面[样例]或者后面加上（0，1），（1，0），（0，1），（1，0），（0，1），（1，0）……即可[每个数，生成两个新的数]，这样保证了只改变一个位数，因为上一轮的数是按照跪着的。所以这样就不会有问题。
附上两次的代码：
WA的代码[我相信是可以过的]：

 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的代码：

 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

这个题其实就是个模拟题，两两交换 listnode 的节点，基于 node 而非 val。蛮简单的，但是我自己确实憋了好久，一次 AC，但是感觉自己的代码写出来永远不美，复用性不高。逻辑不行。还得加油。
附上代码：

 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

注意什么都不输入的越界问题。
每次二分，因为排好序，以中点为根即可。
子树同理。
附上代码：

 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

判断一棵树是否是平衡的二叉查找树。
一次AC附上代码：[原以为自己会超时的]

 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;
 }
};