寫在前面:
由於要準備面試,開始了在[LeetCode]上刷題的歷程。
LeetCode上一共有大約150道題目,本文記錄我在<http://oj.leetcode.com>上AC的全部題目,以Leetcode上AC率由高到低排序,基本上就是題目由易到難。我應該會每AC15題就過來發一篇文章,爭取早日刷完。因此這個第二篇仍是相對比較簡單的15道題了。node
部分答案有參考網上別人的代碼,和leetcode論壇裏的討論,不少答案確定有不完美的地方,歡迎提問,指正和討論。面試
No.16 app
You are climbing a stair case. It takes n steps to reach to the top.this
Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?spa
class Solution { public: int climbStairs(int n) { if(n==0) return 0; if(n==1) return 1; if(n==2) return 2; int A[n]; A[0] = 1; A[1] = 2; for(int i=2; i<n; i++) { A[i] = A[i-2] + A[i-1]; } return A[n-1]; } };
No.17code
Given a roman numeral, convert it to an integer.blog
Input is guaranteed to be within the range from 1 to 3999.排序
class Solution { public: int romanToInt(string s) { int result = 0; for(int i = 0; i<s.length(); i++) { switch (s[i]) { case 'I': { if((i+1) < s.length()){ switch (s[i+1]) { case 'V': result += 4; i++; break; case 'X': result += 9; i++; break; default: result += 1; } } else result += 1; } break; case 'X': { if((i+1)<s.length()){ switch (s[i+1]) { case 'L': result += 40; i++; break; case 'C': result += 90; i++; break; default: result += 10; } } else result += 10; } break; case 'C': { if((i+1)<s.length()){ switch(s[i+1]) { case 'D': result += 400; i++; break; case 'M': result += 900; i++; break; default: result += 100; } } else result += 100; } break; case 'V': result += 5; break; case 'L': result += 50; break; case 'M': result += 1000; break; case 'D': result += 500; break; } } return result; } };
No.17three
Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).ci
For example, this binary tree is symmetric:
1 / \ 2 2 / \ / \ 3 4 4 3
But the following is not:
1 / \ 2 2 \ \ 3 3
Note:
Bonus points if you could solve it both recursively and iteratively.
/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: int help(TreeNode *left, TreeNode *right) { if(left==NULL&&right==NULL) return true; if(left==NULL||right==NULL) return false; if(left->val!=right->val) return false; return(help(left->left,right->right)&&help(left->right,right->left)); } bool isSymmetric(TreeNode *root) { if(!root) return true; return help(root->left,root->right); } };
No.18
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) { if(!l1||!l2) return l1==NULL?l2:l1; ListNode *p = l1, *q = l2, *tmp = NULL,*tmp2 = NULL, *head=NULL; if(p->val<=q->val) head = p; else head = q; while(p&&q) { if(p->val<=q->val) { if(p->next) { tmp = p; p = p->next; continue; } else { p->next = q; return head; } } else { if(tmp) { tmp -> next = q; tmp2 = q; q = p; p = tmp2; } else { tmp2 = q; q = p; p = tmp2; } } } return head; } };
No.19
Given an array where elements are sorted in ascending order, convert it to a height balanced BST.
/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: void insert_Node(TreeNode* &p, int q) { if(!p) { //TreeNode *tmp =NULL; p = (TreeNode*)malloc(sizeof(struct TreeNode)); p->left = NULL; p->right = NULL; p->val = q; return; } if(q>p->val) insert_Node(p->right, q); else insert_Node(p->left, q); } void Insert(TreeNode* &p, vector<int> &num, int low, int high) { if(low>high) return; int mid = (low+high)/2; insert_Node(p,num[mid]); Insert(p, num, low, mid-1); Insert(p, num, mid+1, high); } TreeNode *sortedArrayToBST(vector<int> &num) { if(num.empty()) return NULL; TreeNode *root=NULL; //= (TreeNode*)malloc(sizeof(TreeNode)); int low = 0, high = num.size(); // int mid = (low + high)/2; Insert(root, num, low, high-1); return root; } };
No.20
Given two sorted integer arrays A and B, merge B into A as one sorted array.
Note:
You may assume that A has enough space to hold additional elements from B. The number of elements initialized in A and B are m and n respectively.
class Solution { public: void merge(int A[], int m, int B[], int n) { if(!m&&n) { for(int i = 0; i<n; i++) A[i] = B[i]; } if(!n) return; int i = 0, j = 0, q = 0; while(i < m&&j < n && i+q<m+n) { if(A[i+q]<=B[j]) i++; else { for(int k=m+q;k>i+q;k--) { A[k]=A[k-1]; } A[i+q++] = B[j++]; } } if(i==m) { for(int k = 0; k+j<n; k++) { A[i+q+k] = B[j+k]; } } } };
No.21
Given a linked list, swap every two adjacent nodes and return its head.
For example,
Given 1->2->3->4
, you should return the list as 2->1->4->3
.
Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *swapPairs(ListNode *head) { if(!head) return NULL; if(!(head->next)) return head; ListNode *p = head, *q = head->next, *o = NULL, *tmp = NULL, *h = NULL; o = (ListNode*)malloc(sizeof(struct ListNode)); //tmp = (ListNode*)malloc(sizeof(struct ListNode)); o->next = p; int i = 0; bool flag = false; if(!(q->next)) { head = q; q -> next = p; p->next = NULL; return head; } while(q->next) { if(!(i%2)) { if(p==head) { p->next = q->next; q->next = p; head = q; //flag = true; } else { p->next = q->next; o->next = q; q->next = p; } tmp = p; p = q; q = tmp; } //if() o = p;//o->next; p = q;//p->next; q = q->next; i++; } if(!(i%2)) { p->next = NULL; o->next = q; q->next = p; } return head; } };
No.22
Given numRows, generate the first numRows of Pascal's triangle.
For example, given numRows = 5,
Return
[ [1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1] ]
class Solution { public: vector<vector<int> > generate(int numRows) { vector<int> s,d; vector<vector<int>> r; s.push_back(1); d.push_back(1); d.push_back(1); if(!numRows) return r; r.push_back(s); if(numRows==1) return r; r.push_back(d); if(numRows==2) return r; int tmp = 0; for(int i = 2; i<numRows; i++) { if(!(i%2)) { s.clear(); s.push_back(1); for(int j = 0; j<i-1; j++) { tmp = d[j]+d[j+1]; s.push_back(tmp); } s.push_back(1); r.push_back(s); } if((i%2)) { d.clear(); d.push_back(1); for(int j = 0; j<i-1; j++) { tmp = s[j]+s[j+1]; d.push_back(tmp); } d.push_back(1); r.push_back(d); } } return r; } };
No.23
Say you have an array for which the ith element is the price of a given stock on day i.
If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
class Solution { public: int maxProfit(vector<int> &prices) { if(prices.size()<2) return 0; if(prices.size() == 2) return (prices[1]-prices[0])>0?(prices[1]-prices[0]):0; int low = prices[0], high = 0, result = 0, n = prices.size(), j = 0, tmp = 0; bool flag = false; for( int i = 1; i<n-1; i++ ) { while(prices[i+j]==prices[i+j+1]) j++; if(prices[i]>prices[i-1]&&prices[i]>prices[i+j+1]) { high = prices[i]; tmp = high-low; if(result<tmp) result = tmp; } if(prices[i]<prices[i-1]&&prices[i]<prices[i+j+1]) { if(low>prices[i]) low = prices[i]; } i += j; j = 0; } if(prices[n-1]>prices[n-2]&&prices[n-1]>low) { tmp = prices[n-1] - low; if(result<tmp) result = tmp; } return result; } };
No.24
/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: static int tree_height(const TreeNode* root, bool& balanced) { const int left_height = root->left ? tree_height(root->left, balanced) + 1 : 0; if (!balanced) return 0; const int right_height = root->right ? tree_height(root->right, balanced) + 1 : 0; if (!balanced) return 0; const int diff = left_height - right_height; if (diff < -1 || diff > 1) balanced = false; return (left_height > right_height ? left_height : right_height); } bool isBalanced(TreeNode *root) { bool balanced = true; if (root) tree_height(root, balanced); return balanced; } };
No.25
Given an integer, convert it to a roman numeral.
Input is guaranteed to be within the range from 1 to 3999.
class Solution { public: string intToRoman(int num) { string s; s.clear(); while(num) { if(num>=1000) { s += "M"; num -= 1000; continue; } else if(num>=900) { s += "CM"; num -= 900; continue; } else if(num>=500) { s += "D"; num -= 500; continue; } else if(num>=400) { s += "CD"; num -= 400; continue; } else if(num>=100) { s += "C"; num -= 100; continue; } else if(num>=90) { s += "XC"; num -= 90; continue; } else if(num>=50) { s += "L"; num -= 50; continue; } else if(num>=40) { s += "XL"; num -= 40; continue; } else if(num>=10) { s += "X"; num -= 10; continue; } else if(num>=9) { s +="IX"; num -= 9; continue; } else if(num>=5) { s +="V"; num -= 5; continue; } else if(num>=4) { s +="IV"; num -= 4; continue; } else if(num>=1) { s +="I"; num -= 1; continue; } } return s; } };
No.26
Given an array of integers, every element appears three times except for one. Find that single one.
Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
class Solution { public: int singleNumber(int A[], int n) { int count[32] = {0}; int result = 0; for(int i = 0; i < n; i++) { for(int j = 0; j<32; j++) { if((A[i]>>j)&1) count[j]++; if(!(count[j]%3)) count[j] = 0; } } for(int i = 0; i<32; i++) { result += (count[i]<<i); } return result; } };
No.27
Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).
For example:
Given binary tree {3,9,20,#,#,15,7}
,
3 / \ 9 20 / \ 15 7
return its bottom-up level order traversal as:
[ [15,7] [9,20], [3], ]
/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { private: vector<vector<int>> r; vector<int> t; public: int getDepth(TreeNode *root) { if(!root) return 0; int leftDepth = getDepth(root->left); int rightDepth = getDepth(root->right); return leftDepth>rightDepth?(leftDepth+1):(rightDepth+1); } void helper(TreeNode *root, int level) { if(!root||level<0) return; if(!level) t.push_back(root->val); helper(root->left, level-1); helper(root->right, level-1); } vector<vector<int> > levelOrderBottom(TreeNode *root) { r.clear(); t.clear(); if(!root) return r; int depth = getDepth(root); for(int i = depth - 1; i>-1; i--) { helper(root,i); r.push_back(t); t.clear(); } return r; } };
未完待續...