LeetCode 刷题记录(二）
写在前面：
因为要准备面试，开始了在[LeetCode]上刷题的历程。
LeetCode上一共有大约150道题目，本文记录我在<http://oj.leetcode.com>上AC的所有题目，以Leetcode上AC率由高到低排序，基本上就是题目由易到难。我应该会每AC15题就过来发一篇文章，争取早日刷完。所以这个第二篇还是相对比较简单的15道题了。
部分答案有参考网上别人的代码，和leetcode论坛里的讨论，很多答案肯定有不完美的地方，欢迎提问，指正和讨论。
No.16
Climbing Stairs
You are climbing a stair case. It takes n steps to reach to the top.
Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
class Solution {
public:
int climbStairs(int n) {
if(n==) return ;
if(n==) return ;
if(n==) return ;
int A[n];
A[] = ;
A[] = ;
for(int i=; i<n; i++)
{
A[i] = A[i-] + A[i-];
}
return A[n-];
}
};
No.17
Roman to Integer
Total Accepted: 3141 Total Submissions: 9694
Given a roman numeral, convert it to an integer.
Input is guaranteed to be within the range from 1 to 3999.
class Solution {
public:
int romanToInt(string s) {
int result = ;
for(int i = ; i<s.length(); i++)
{
switch (s[i])
{
case 'I':
{
if((i+) < s.length()){
switch (s[i+])
{
case 'V':
result += ;
i++;
break;
case 'X':
result += ;
i++;
break;
default: result += ;
}
}
else result += ;
}
break;
case 'X':
{
if((i+)<s.length()){
switch (s[i+])
{
case 'L':
result += ;
i++;
break;
case 'C':
result += ;
i++;
break;
default:
result += ;
}
}
else result += ;
}
break;
case 'C':
{
if((i+)<s.length()){
switch(s[i+])
{
case 'D':
result += ;
i++;
break;
case 'M':
result += ;
i++;
break;
default:
result += ;
}
}
else result += ;
}
break;
case 'V':
result += ;
break;
case 'L':
result += ;
break;
case 'M':
result += ;
break;
case 'D':
result += ;
break;
}
}
return result;
}
};
No.17
Symmetric Tree
Total Accepted: 5574 Total Submissions: 17286
Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
For example, this binary tree is symmetric:
/ \
/ \ / \
But the following is not:
/ \
\ \
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
Merge Two Sorted Lists
Total Accepted: 5328 Total Submissions: 16521
Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
/**
* 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
Convert Sorted Array to Binary Search Tree
Total Accepted: 4576 Total Submissions: 14314
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)/;
insert_Node(p,num[mid]);
Insert(p, num, low, mid-);
Insert(p, num, mid+, high);
}
TreeNode *sortedArrayToBST(vector<int> &num) {
if(num.empty())
return NULL;
TreeNode *root=NULL; //= (TreeNode*)malloc(sizeof(TreeNode));
int low = , high = num.size();
// int mid = (low + high)/2; Insert(root, num, low, high-); return root;
}
};
No.20
Merge Sorted Array
Total Accepted: 5000 Total Submissions: 15668
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 = ; i<n; i++)
A[i] = B[i];
}
if(!n) return;
int i = , j = , q = ;
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-];
}
A[i+q++] = B[j++];
}
}
if(i==m)
{
for(int k = ; k+j<n; k++)
{
A[i+q+k] = B[j+k];
}
}
}
};
No.21
Swap Nodes in Pairs
Total Accepted: 4789 Total Submissions: 15074
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 = ;
bool flag = false;
if(!(q->next))
{
head = q;
q -> next = p;
p->next = NULL;
return head;
}
while(q->next)
{
if(!(i%))
{
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%))
{
p->next = NULL;
o->next = q;
q->next = p;
} return head;
}
};
No.22
Pascal's Triangle
Total Accepted: 4251 Total Submissions: 13505
Given numRows, generate the first numRows of Pascal's triangle.
For example, given numRows = 5,
Return
[
[],
[,],
[,,],
[,,,],
[,,,,]
]
class Solution {
public:
vector<vector<int> > generate(int numRows) {
vector<int> s,d;
vector<vector<int>> r;
s.push_back();
d.push_back();
d.push_back();
if(!numRows) return r;
r.push_back(s);
if(numRows==) return r;
r.push_back(d);
if(numRows==) return r;
int tmp = ;
for(int i = ; i<numRows; i++)
{
if(!(i%))
{
s.clear();
s.push_back();
for(int j = ; j<i-; j++)
{
tmp = d[j]+d[j+];
s.push_back(tmp);
}
s.push_back();
r.push_back(s);
}
if((i%))
{
d.clear();
d.push_back();
for(int j = ; j<i-; j++)
{
tmp = s[j]+s[j+];
d.push_back(tmp);
}
d.push_back();
r.push_back(d);
}
}
return r;
}
};
No.23
Best Time to Buy and Sell Stock
Total Accepted: 5232 Total Submissions: 16683
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()<) return ;
if(prices.size() == ) return (prices[]-prices[])>?(prices[]-prices[]):;
int low = prices[], high = , result = , n = prices.size(), j = , tmp = ;
bool flag = false;
for( int i = ; i<n-; i++ )
{
while(prices[i+j]==prices[i+j+]) j++;
if(prices[i]>prices[i-]&&prices[i]>prices[i+j+])
{
high = prices[i];
tmp = high-low;
if(result<tmp)
result = tmp;
}
if(prices[i]<prices[i-]&&prices[i]<prices[i+j+])
{
if(low>prices[i])
low = prices[i];
}
i += j;
j = ;
}
if(prices[n-]>prices[n-]&&prices[n-]>low)
{
tmp = prices[n-] - low;
if(result<tmp)
result = tmp;
}
return result;
}
};
No.24
Balanced Binary Tree
Total Accepted: 5256 Total Submissions: 16787
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
/**
* 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) + : ; if (!balanced) return ; const int right_height = root->right ? tree_height(root->right, balanced) + : ; if (!balanced) return ; const int diff = left_height - right_height; if (diff < - || diff > ) 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
Integer to Roman
Total Accepted: 2969 Total Submissions: 9554
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>=)
{
s += "M";
num -= ;
continue;
}
else if(num>=)
{
s += "CM";
num -= ;
continue;
}
else if(num>=)
{
s += "D";
num -= ;
continue;
}
else if(num>=)
{
s += "CD";
num -= ;
continue;
}
else if(num>=)
{
s += "C";
num -= ;
continue;
}
else if(num>=)
{
s += "XC";
num -= ;
continue;
}
else if(num>=)
{
s += "L";
num -= ;
continue;
}
else if(num>=)
{
s += "XL";
num -= ;
continue;
}
else if(num>=)
{
s += "X";
num -= ;
continue;
}
else if(num>=)
{
s +="IX";
num -= ;
continue;
}
else if(num>=)
{
s +="V";
num -= ;
continue;
}
else if(num>=)
{
s +="IV";
num -= ;
continue;
}
else if(num>=)
{
s +="I";
num -= ;
continue;
}
}
return s;
}
};
No.26
Single Number II
Total Accepted: 5597 Total Submissions: 18201
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[] = {};
int result = ;
for(int i = ; i < n; i++)
{
for(int j = ; j<; j++)
{
if((A[i]>>j)&)
count[j]++;
if(!(count[j]%))
count[j] = ;
}
}
for(int i = ; i<; i++)
{
result += (count[i]<<i);
}
return result;
}
};
No.27
Binary Tree Level Order Traversal II
Total Accepted: 3757 Total Submissions: 12234
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 ;
int leftDepth = getDepth(root->left);
int rightDepth = getDepth(root->right);
return leftDepth>rightDepth?(leftDepth+):(rightDepth+);
}
void helper(TreeNode *root, int level)
{
if(!root||level<) return;
if(!level) t.push_back(root->val);
helper(root->left, level-);
helper(root->right, level-);
}
vector<vector<int> > levelOrderBottom(TreeNode *root) {
r.clear();
t.clear();
if(!root) return r;
int depth = getDepth(root);
for(int i = depth - ; i>-; i--)
{
helper(root,i);
r.push_back(t);
t.clear();
}
return r;
}
};
未完待续...
LeetCode 刷题记录(二）的更多相关文章
- leetcode刷题记录--js
leetcode刷题记录 两数之和 给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标. 你可以假设每种输入只会对应一个答案.但 ...
- Leetcode刷题记录（python3）
Leetcode刷题记录(python3) 顺序刷题 1~5 ---1.两数之和 ---2.两数相加 ---3. 无重复字符的最长子串 ---4.寻找两个有序数组的中位数 ---5.最长回文子串 6- ...
- LeetCode刷题记录(python3)
由于之前对算法题接触不多,因此暂时只做easy和medium难度的题. 看完了<算法(第四版)>后重新开始刷LeetCode了,这次决定按topic来刷题,有一个大致的方向.有些题不止包含 ...
- leetcode 刷题记录(java)-持续更新
最新更新时间 11:22:29 8. String to Integer (atoi) public static int myAtoi(String str) { // 1字符串非空判断 " ...
- LeetCode 刷题记录
写在前面:因为要准备面试,开始了在[LeetCode]上刷题的历程.LeetCode上一共有大约150道题目,本文记录我在<http://oj.leetcode.com>上AC的所有题目, ...
- leetcode刷题记录——树
递归 104.二叉树的最大深度 /** * Definition for a binary tree node. * public class TreeNode { * int val; * Tree ...
- 算法进阶之Leetcode刷题记录
目录 引言 题目 1.两数之和 题目 解题笔记 7.反转整数 题目 解题笔记 9.回文数 题目 解题笔记 13.罗马数字转整数 题目 解题笔记 14.最长公共前缀 题目 解题笔记 20.有效的括号 题 ...
- leetCode刷题记录
(1)Linked List Cycle Total Accepted: 13297 Total Submissions: 38411 Given a linked list, determine i ...
- leetcode刷题记录——数组与矩阵
@ 目录 283. 移动零 566. 重塑矩阵 485. 最大连续1的个数 240. 搜索二维矩阵 II 378. 有序矩阵中第K小的元素 645. 错误的集合 287. 寻找重复数 667. 优美的 ...
随机推荐
- HTML xmlns
xmlns 属性可以在文档中定义一个或多个可供选择的命名空间.该属性可以放置在文档内任何元素的开始标签中.该属性的值类似于 URL,它定义了一个命名空间,浏览器会将此命名空间用于该属性所在元素内的所有 ...
- OE中admin的内置帐号
在OE中admin的内置帐号为SUPERUSER_ID,可以用来直接做判断登录用户是否admin from openerp import SUPERUSER_ID if uid == SUPERUSE ...
- 并行编译 Xoreax IncrediBuild
好东西... http://pan.baidu.com/s/1BtZ4s
- Servlet容器的启动(Tomcat为例)
一.容器简介 在tomcat容器等级中,context容器直接管理servlet在容器中的包装类Wrapper,所以Context容器如何运行将直接影响servlet的工作方式. tomcat容器模型 ...
- 【转】Github轻松上手4-常用的git命令
转自:http://blog.sina.com.cn/s/blog_4b55f6860100zzih.html 附上一些git的常见命令: • git remote add origin git ...
- NodeJS学习笔记之MongoDB模块
其中还有,nodejs远程连接mysql数据库 一,开篇分析 这篇属于扩展知识篇,因为在下面的文章中会用到数据库操作,所以今天就来说说它(Mongodb模块). (1),简介 MongoDB是一个基于 ...
- Node.js的循环依赖
我们知道在实际编程过程中,要尽可能的减少或者规避循环依赖情况的发生.但在现实环境中,有时却不得不产生循环依赖.Node.js不提倡使用循环依赖,但真有如此情况发生时Node.js也有办法解决.这篇博文 ...
- 挺好看的CSS
<?php header("content-type:text/html;charset=utf-8"); echo "<style>h1{ color ...
- hdu 2516（斐波拉切博弈）
题意:容易理解. 分析:通过枚举寻找规律,这就是做1堆或者2堆石子博弈的技巧!当为2或者3时,肯定是第二个人赢,当为4时,先去一个石子,然后当对方面临3,于是第一个人赢, 当为5时,取1时,第二个人赢 ...
- ansible playbook最佳实践
本篇主要是根据官方翻译而来,从而使简单的翻译,并没有相关的实验步骤,以后文章会补充为实验步骤,此篇主要是相关理论的说明,可以称之为中文手册之一,具体内容如下: Ansible playbooks最佳实 ...