leetcode之旅（简单题0-50）
@TOC
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
两遍哈希表
- 迭代，将每个元素的值和它的索引添加到表中
- 迭代，将检查每个元素所对应的目标元素（target - nums[i]target−nums[i]）是否存在于表中
知识点
map：map容器，第一个类型的键类型，第二个是值类型
vector twoSum(vector& nums, int target)
{
vector twoSum;
map tmpmap;
for(int i=0; i 两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* head = new ListNode(-1);
ListNode* cur = head;
int sum = 0;
bool carry = false;
while(l1 != NULL || l2 != NULL){
sum = 0;
if(l1 != NULL){
sum += l1->val;
l1 = l1 -> next;
}
if(l2 != NULL){
sum += l2->val;
l2 = l2 -> next;
}
if(carry)
sum++;
cur -> next = new ListNode(sum % 10);
cur = cur -> next;
carry = sum >= 10 ? true: false;
}
if(carry)
cur -> next = new ListNode(1);
return head -> next;
}
无重复字符的最长子串
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
现学现用，map
class Solution {
public:
int lengthOfLongestSubstring(string s) {
mapdict;
int cur = 0, max_seq = 0;
int start = 0;
for(int i=0; i::iterator iter;
iter = dict.find(s[i]);
if( iter !=dict.end() )//重复
{
cur = i - dict[s[i]];
for(int j=start; j<=dict[s[i]]; j++)
dict.erase(s[j]);
start = i - cur + 1;
}
else
{
cur += 1;
}
dict[s[i]] = i;
if(cur > max_seq)
max_seq = cur;
}
return max_seq;
}
};
整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
输入: 123
输出: 321
int reverse(int x) {
bool minus = false;
long res;
if(x<0)
{
minus = true;
}
string s = to_string(x);
if(!minus) s = s.substr(1);
for(int j=0; j0x7fffffff || res<(signed int)0x80000000)
return 0;
else return res;
}
判断32位有符号整数溢出
if( num>0x7fffffff || num<(signed int)0x80000000)
字符转整数
int a = atoi(s.c_str());
整数转字符
std::to_string(i)
回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
class Solution {
public:
bool isPalindrome(int x) {
string s = to_string(x);
int l = s.length();
int pos = 0;
for(int i=0; i其他思想：为了避免数字反转可能导致的溢出问题，为什么不考虑只反转 \text{int}int 数字的一半？毕竟，如果该数字是回文，其后半部分反转后应该与原始数字的前半部分相同。
例如，输入 1221，我们可以将数字“1221”的后半部分从“21”反转为“12”，并将其与前半部分“12”进行比较，因为二者相同，我们得知数字 1221 是回文。
罗马数字转整数
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
class Solution {
public:
int romanToInt(string s) {
map numbers;
numbers['I'] = 1;
numbers['V'] = 5;
numbers['X'] = 10;
numbers['L'] = 50;
numbers['C'] = 100;
numbers['D'] = 500;
numbers['M'] = 1000;
int num = 0;
for(int i=0; i 执行用时: 136 ms, 在Roman to Integer的C++提交中击败了0.84% 的用户
内存消耗: 33.3 MB, 在Roman to Integer的C++提交中击败了0.33% 的用户
效果不是很好呀
最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
输入: [“flower”,“flow”,“flight”]
输出: “fl”
class Solution {
public:
string longestCommonPrefix(vector& strs) {
int nums = strs.size();
int j=0, count = 0;
char s;
string res = "";
if(strs.size()<=0) return res;
for(int j=0; j 执行用时: 20 ms, 在Longest Common Prefix的C++提交中击败了8.38% 的用户
内存消耗: 9.3 MB, 在Longest Common Prefix的C++提交中击败了0.90% 的用户
有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
class Solution {
public:
bool isValid(string s) {
int l = s.length();
char tmp;
if(l == 0) return true;
if(l%2 !=0) return false;
stack S1;
stack S2;
for(int i=0; i 执行用时: 12 ms, 在Valid Parentheses的C++提交中击败了13.39% 的用户
内存消耗: 9.3 MB, 在Valid Parentheses的C++提交中击败了0.93% 的用户
合并两个有序链表
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode *p = l1;
ListNode *q = l2;
ListNode *head = new ListNode(-1);
ListNode *res = head;
while(p!=nullptr && q!=nullptr)
{
if(p->val <= q->val)
{
res->next = p;
p = p->next;
}
else
{
res->next = q;
q = q->next;
}
res = res->next;
}
if(p!=nullptr) res->next = p;
else if(q!=nullptr) res->next = q;
return head->next;
}
};
小彩蛋——报数
报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：
1: 1
2: 11
3: 21
4: 1211
5: 111221
给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。
这个题…emmmm…它说了个啥？？？？
于是我就翻评论…
哈哈哈哈哈哈红红火火恍恍惚惚
其实就是个计数啦
2因为1有一个1，所以11；
3因为2有两个1，所以21；
4因为3是一个2，一个1，所以1211；
5因为4是一个1，一个2，两个1，所以111221；
6因为5是三个1，两个2，一个1，所以312211；
··· ···
其实就是统计数量计数，再字符串转数字的过程。
class Solution {
public:
string countAndSay(int n) {
string s;
if (n==1)
s = "1";
else
s = map(countAndSay(n-1));
return s;
}
string map(string s){
string res;
for (int i=0;i执行用时: 16 ms, 在Count and Say的C++提交中击败了10.91% 的用户
内存消耗: 9.1 MB, 在Count and Say的C++提交中击败了0.72% 的用户
最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
感觉我最喜欢的就是动态规划了
class Solution {
public:
int maxSubArray(vector& nums) {
int maxNum = INT_MIN;
int sum=0;
for(int i=0; i=0) sum += nums[i];
else sum = nums[i];
if(sum > maxNum) maxNum = sum;
}
return maxNum;
}
};
执行用时: 60 ms, 在Maximum Subarray的C++提交中击败了8.45% 的用户
内存消耗: 10.5 MB, 在Maximum Subarray的C++提交中击败了0.94% 的用户
最后一个单词的长度
给定一个仅包含大小写字母和空格 ’ ’ 的字符串，返回其最后一个单词的长度。如果不存在最后一个单词，请返回 0
class Solution {
public:
int lengthOfLastWord(string s) {
int count = 0;
for(int i=s.length()-1; i>=0; i--)
{
if(s[i]!= ' ')
count+=1;
else if(s[i] == ' '&& count==0) continue;
else break;
}
return count;
}
};
执行用时: 8 ms, 在Length of Last Word的C++提交中击败了18.33% 的用户
内存消耗: 9.1 MB, 在Length of Last Word的C++提交中击败了0.82% 的用户
加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
class Solution {
public:
vector plusOne(vector& digits) {
bool carry = false;
int n = digits.size();
if(digits[n-1] == 9)
{
carry = true;
}
else
{
digits[n-1] += 1;
return digits;
}
while(carry)
{
if(n == 1)
{
if(digits[n-1] == 9)
{
digits.insert(digits.begin(), 1);
digits[n] = 0;
}
else digits[n-1] += 1;
carry = false;
}
else
{
if(digits[n-1] == 9)
{
digits[n-1] = 0;
n = n-1;
}
else
{
carry = false;
digits[n-1] += 1;
}
}
}
return digits;
}
};
执行用时: 12 ms, 在Plus One的C++提交中击败了12.00% 的用户
内存消耗: 8.6 MB, 在Plus One的C++提交中击败了0.87% 的用户
二进制求和
给定两个二进制字符串，返回他们的和（用二进制表示）。
输入为非空字符串且只包含数字 1 和 0。
我这个感觉写的好笨哦
class Solution {
public:
string addBinary(string a, string b) {
int carry = 0;
int i = a.length();
int j = b.length();
int tmp =0;
string res = "";
while(i!=0 && j!=0)
{
tmp = a[i-1] - '0' + b[j-1] - '0' + carry;
if(tmp==2)
{
res = '0'+res;
carry = 1;
}
else if(tmp==3)
{
res = '1'+res;
carry = 1;
}
else
{
if(tmp == 0) res = '0' + res;
else res = '1' +res;
carry = 0;
}
i--;
j--;
}
while(carry)
{
if(j==0 && i==0)
{
res = '1' + res;
carry = 0;
}
else if(i!=0)
{
tmp = a[i-1] - '0' + carry;
if(tmp==2)
{
res = '0'+res;
carry = 1;
}
else if(tmp==3)
{
res = '1'+res;
carry = 1;
}
else
{
if(tmp == 0) res = '0' + res;
else res = '1' +res;
carry = 0;
}
i--;
}
else if(j!=0)
{
tmp = b[j-1] - '0' + carry;
if(tmp==2)
{
res = '0'+res;
carry = 1;
}
else if(tmp==3)
{
res = '0'+res;
carry = 1;
}
else
{
if(tmp == 0) res = '0' + res;
else res = '1' +res;
carry = 0;
}
j--;
}
}
if(i!=0) res = a.substr(0, i) +res;
else if(j!=0) res = b.substr(0, j) +res;
return res;
}
};
执行用时: 16 ms, 在Add Binary的C++提交中击败了13.37% 的用户
内存消耗: 9 MB, 在Add Binary的C++提交中击败了0.79% 的用户
class Solution {
public:
string addBinary(string a, string b) {
string s = "";
int c = 0, i = a.size() - 1, j = b.size() - 1;
while(i >= 0 || j >= 0 || c == 1)
{
c += (i >= 0 ? a[i --] - '0' : 0);
c += (j >= 0 ? b[j --] - '0' : 0);
s = char(c % 2 + '0') + s; //前一项充当该位结果，然后与原来的s相连接，
//相当于在s前插入了该项
c /= 2; //充当进位
}
//a[i --] - '0' 减法得到一个int数
//char(c % 2 + '0') 内部加法得到1的ASC码，char将其转化为字符 因此这两处加减法不能混
return s;
}
};
x 的平方根
实现 int sqrt(int x) 函数
感觉看评论能被笑死
哈哈哈哈哈哈老哥何必要欺骗自己…
emmm，不过细想我好想也不会做啊…
这里找到一个解法：牛顿迭代法
https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division
class Solution {
public:
int mySqrt(int x) {
double res;
if(x <= 1) return x;
res = x;
while(res > x/res)
{
res = (res +x/res) /2;
if(res == (res+x/res) /2)
break;
}
return res;
}
};
执行用时: 28 ms, 在Sqrt(x)的C++提交中击败了24.66% 的用户
内存消耗: 14 MB, 在Sqrt(x)的C++提交中击败了0.41% 的用户
爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
在剑指offer做过，哈哈哈哈哈
class Solution {
public:
int climbStairs(int n) {
if(n==1) return 1;
else if(n==2) return 2;
else
{
return climbStairs(n-1) + climbStairs(n-2);
}
}
};
噫！超出时间限制了！
class Solution {
public:
int climbStairs(int n) {
int res = 0;
int step1 = 1, step2 = 2;
if(n==1) res = step1;
else if(n==2) res = step2;
else
{
for(int i=3; i<=n; i++)
{
res = step1+step2;
step1 = step2;
step2 = res;
}
}
return res;
}
};
执行用时: 8 ms, 在Climbing Stairs的C++提交中击败了15.15% 的用户
内存消耗: 8.5 MB, 在Climbing Stairs的C++提交中击败了0.85% 的用户
删除排序链表中的重复元素
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
ListNode *p = head;
if(p==nullptr) return head;
while(p->next != nullptr)
{
if(p->next->val == p->val)
p->next = p->next->next;
else
p = p->next;
}
return head;
}
};
执行用时: 32 ms, 在Remove Duplicates from Sorted List的C++提交中击败了3.20% 的用户
内存消耗: 9.3 MB, 在Remove Duplicates from Sorted List的C++提交中击败了0.99% 的用户
合并两个有序数组
给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组
class Solution {
public:
void merge(vector& nums1, int m, vector& nums2, int n) {
if(m==0)
{
nums1 = nums2;
return;
}
if(n==0)
{
return;
}
for(int j = n-1; j>=0; j--)
{
for(int i = m-1; i>=0; i--)
{
if(nums1[i]<=nums2[j])
{
nums1[i+1] = nums2[j];
m++;
break;
}
else
{
nums1[i+1] = nums1[i];
if(i==0)
{
nums1[0] = nums2[j];
m++;
}
}
}
}
}
};
ps.今天get了键盘，感觉敲起来好不习惯
执行用时: 12 ms, 在Merge Sorted Array的C++提交中击败了14.31% 的用户
内存消耗: 9.1 MB, 在Merge Sorted Array的C++提交中击败了0.00% 的用户
相同的树
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(p==nullptr && q==nullptr) return true;
if(p!=nullptr && q != nullptr)
{
if(p->val == q->val)
{
return (isSameTree(p->left, q->left) && isSameTree(p->right, q->right));
}
return false;
}
return false;
}
};
执行用时: 8 ms, 在Same Tree的C++提交中击败了15.11% 的用户
内存消耗: 10 MB, 在Same Tree的C++提交中击败了0.34% 的用户
呀，我真是个笨蛋
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if (p==NULL && q==NULL) return true;
if (p==NULL || q==NULL) return false;
if (p->val!=q->val) return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
对称二叉树
给定一个二叉树，检查它是否是镜像对称的。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(root==nullptr) return true;
else return Symmetric(root->left, root->right);
}
bool Symmetric(TreeNode *p, TreeNode *q)
{
if(p==nullptr && q==nullptr) return true;
if(p==nullptr || q==nullptr || p->val != q->val) return false;
else
return (Symmetric(p->right, q->left) && Symmetric(p->left, q->right));
}
};
执行用时 : 24 ms, 在Symmetric Tree的C++提交中击败了4.29% 的用户
内存消耗 : 15.8 MB, 在Symmetric Tree的C++提交中击败了0.95% 的用户
高效答案用了个栈
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(!root) return true;
stack Q;
Q.push(root->left);
Q.push(root->right);
while(!Q.empty()){
TreeNode* r1=Q.top();Q.pop();
TreeNode* r2=Q.top();Q.pop();
if(!r1 && !r2) continue;
if(r1 && r2){
if(r1->val != r2->val) return false;
Q.push(r1->left);Q.push(r2->right);
Q.push(r1->right);Q.push(r2->left);
}else return false;
}
return true;
}
};
妙啊～
杨辉三角
给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
class Solution {
public:
vector> generate(int numRows) {
vector > res(numRows, vector(numRows, 0));
for(int i=0; i< numRows; i++)
{
for(int j=0; j<=i; j++)
{
if(j==0 || j==i)
res[i][j] = 1;
else res[i][j] = res[i-1][j-1]+res[i-1][j];
}
}
for(int i=0; i 执行用时 : 8 ms, 在Pascal’s Triangle的C++提交中击败了16.46% 的用户
内存消耗 : 8.4 MB, 在Pascal’s Triangle的C++提交中击败了0.70% 的用户
vector 二维数组vector：初始化
杨辉三角II
给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。
class Solution {
public:
vector getRow(int rowIndex) {
vectortmp;
vectorres;
if(rowIndex==0) return {1};
for(int i=0; i<=rowIndex; i++)
{
res.clear();
for(int j=0; j<= i; j++)
{
if(j==0 || j==i) res.push_back(1);
else res.push_back(tmp[j-1] + tmp[j]);
}
tmp = res;
}
return res;
}
};
执行用时 : 8 ms, 在Pascal’s Triangle II的C++提交中击败了17.19% 的用户
内存消耗 : 8.4 MB, 在Pascal’s Triangle II的C++提交中击败了0.65% 的用户
也可以倒着来
class Solution {
public:
vector getRow(int rowIndex) {
vector res(rowIndex + 1);
res[0] = 1;
for (int i = 1; i <= rowIndex; ++i) {
for (int j = i; j >= 1; --j) {
res[j] += res[j - 1];
}
}
return res;
}
};
买卖股票的最佳时机
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
注意你不能在买入股票前卖出股票。
动态规划：第i 天的差额= max{第i-1天差额 + i - i-1 的钱钱 ， 第i天的钱钱-前几天最小的钱钱}
class Solution {
public:
int maxProfit(vector& prices) {
int maxProfit = INT_MIN;
int b = 0;
int l = prices.size();
if(l<=1) return 0;
int minPrice = prices[0];
for(int i=1; i 执行用时 : 12 ms, 在Best Time to Buy and Sell Stock的C++提交中击败了37.84% 的用户
内存消耗 : 9.5 MB, 在Best Time to Buy and Sell Stock的C++提交中击败了0.87% 的用户
买卖股票的最佳时机 II
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
class Solution {
public:
int maxProfit(vector& prices) {
int maxProfit = INT_MIN;
int b=0;
int l = prices.size();
if(l<=1) return 0;
for(int i=1; i 0) b += profit;
if(b > maxProfit) maxProfit = b;
}
return maxProfit;
}
};
执行用时 : 12 ms, 在Best Time to Buy and Sell Stock II的C++提交中击败了18.92% 的用户
内存消耗 : 9.5 MB, 在Best Time to Buy and Sell Stock II的C++提交中击败了0.95% 的用户
验证回文串
给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
好笨的解题过程，并且绕进去了
class Solution {
public:
bool isPalindrome(string s) {
int l = s.length();
if(l<=1) return true;
bool flag = true;
int i=0, j=l-1;
while(i!=j && i-j!=1)
{
int a = (int)s[i];
int b = (int)s[j];
if((a>=65 && a<=90) ||( a>=97 && a<=122) ||(a>=48 && a<=57))
{
if((b>=65 && b<=90) ||( b>=97 && b<=122) ||(b>=48 && b<=57))
{
if(a>=97 && a<=122) a = a-32;
if(b>=97 && b<=122) b = b-32;
if(a==b)
{
i++;j--;
}
else
{
flag = false;
break;
}
}
else j--;
}
else
{
i ++;
}
}
return flag;
}
};
执行用时 : 68 ms, 在Valid Palindrome的C++提交中击败了5.39% 的用户
内存消耗 : 9.1 MB, 在Valid Palindrome的C++提交中击败了0.72% 的用户
class Solution {
public:
bool isPalindrome(string s) {
string str="";
int len=s.length();
int lenStr=0;
for(int i=0;i='a'&&s[i]<='z')||(s[i]>='0'&&s[i]<='9')){
str+=s[i];
lenStr++;
}
else if(s[i]>='A'&&s[i]<='Z'){
str+=(s[i]-'A'+'a');
lenStr++;
}
}
for(int i=0;i 颠倒二进制位
颠倒给定的 32 位无符号整数的二进制位。
uint32_t reverseBits(uint32_t n) {
uint32_t ans=0;
int i=32;
while(i--)
{
//*2
ans<<=1;
ans+=n&1;
n>>=1;
}
return ans;
}
执行用时: 12 ms, 在Reverse Bits的C++提交中击败了14.33% 的用户
内存消耗: 7.9 MB, 在Reverse Bits的C++提交中击败了0.65% 的用户
位1的个数
编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
class Solution {
public:
int hammingWeight(uint32_t n) {
int count = 0;
while(n>0)
{
if(n%2 == 1) count++;
n>>=1;
}
return count;
}
};
执行用时: 28 ms, 在Number of 1 Bits的C++提交中击败了3.51% 的用户
内存消耗: 8.2 MB, 在Number of 1 Bits的C++提交中击败了0.45% 的用户