1.给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
map<int,int> a;//提供一对一的hash
vector<int> b(2,-1);//用来承载结果，初始化一个大小为2，值为-1的容器b
for(int i=0;i<nums.size();i++)
{
if(a.count(target-nums[i])>0)
{
b[0]=a[target-nums[i]];//查找是否已经放进去过之前一个
b[1]=i;
break;
}
a[nums[i]]=i;//反过来放入map中，用来获取结果下标
}
return b;
};
};
2.给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。
函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。
说明:
返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例:
输入: numbers = [2, 7, 11, 15], target = 9 输出: [1,2] 解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
class Solution {
public:
vector<int> twoSum(vector<int>& numbers, int target) {
int i = 0, j = numbers.size()-1;
while (i != j) {
int sum = numbers[i] + numbers[j];
if (sum > target) j--;
else if (sum < target) i++;
else break;
}
return vector<int> {i+1, j+1};
}
};
3.给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123 输出: 321
示例 2:
输入: -123 输出: -321
示例 3:
输入: 120 输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
class Solution {
public:
int reverse(int x) {
int max = 0x7fffffff, min = 0x80000000;//int的最大值最小值
long rs = 0;//用long类型判断溢出
for(;x;rs = rs*10+x%10,x/=10);//逆序，正负通吃，不用单独考虑负值
return rs>max||rs<min?0:rs;//超了最大值低于最小值就返回0
}
};
4.判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121 输出: true
示例 2:
输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10 输出: false 解释: 从右向左读, 为 01 。因此它不是一个回文数。
class Solution {
public:
bool isPalindrome(int x) {
long i=0,j=x;
for(;x;i=i*10+x%10,x/=10);
return j<0 ? false:(j==i ? true : false);
}
};
5.罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
示例 1:
输入: "III" 输出: 3
class Solution {
public:
int romanToInt(string s) {
int sum=0;
map<char,int> m;
m['I']=1;
m['V']=5;
m['X']=10;
m['L']=50;
m['C']=100;
m['D']=500;
m['M']=1000;
int i=0;
for(;i<s.length();i++)
{
if(m[s[i]]>=m[s[i+1]])
sum+=m[s[i]];
else
sum-=m[s[i]];
}
return sum+m[s[i]];
}
};
6.编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1:
输入: ["flower","flow","flight"] 输出: "fl"
示例 2:
输入: ["dog","racecar","car"] 输出: "" 解释: 输入不存在公共前缀。
说明:
所有输入只包含小写字母 a-z 。
class Solution {
public:
string longestCommonPrefix(vector<string>& strs) {
if (strs.empty())
return "";
string prefix = strs[0];
for (size_t i = 1; i < strs.size(); ++i)
{
while (strs[i].find(prefix) !=0)
{
prefix = prefix.substr(0, prefix.size() - 1);
if (prefix.empty())
return "";
}
}
return prefix;
}
};
7.给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: "()" 输出: true
示例 2:
输入: "()[]{}" 输出: true
示例 3:
输入: "(]" 输出: false
示例 4:
输入: "([)]" 输出: false
示例 5:
输入: "{[]}" 输出: true
class Solution {
public:
bool isValid(string s) {
stack<char> Stack;
for(int i=0;i<s.size();i++)
{
switch (s[i])
{
case')':
if(Stack.empty()||Stack.top()!='(')
return false;
Stack.pop();
break;
case']':
if(Stack.empty()||Stack.top()!='[')
return false;
Stack.pop();
break;
case'}':
if(Stack.empty()||Stack.top()!='{')
return false;
Stack.pop();
break;
default:
Stack.push(s[i]);
break;
}
}
if(Stack.empty())
return true;
return false;
}
};
8.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4
/**
* 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) {
ListNode *p=new ListNode(0);
ListNode *r=p;
while(l2&&l1)
{
if(l2->val>l1->val)
{
p->next=l1;
l1=l1->next;
p=p->next;
}
else
{
p->next=l2;
l2=l2->next;
p=p->next;
}
}
p->next=(l1)?(l1):(l2);
return r->next;
}
};
9.给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。
例如，给出 n = 3，生成结果为：
[ "((()))", "(()())", "(())()", "()(())", "()()()" ]
class Solution {
public:
vector<string> generateParenthesis(int n) {
vector<string> s;
fun(s,"",0,0,n);
return s;
}
void fun(vector<string> &s,string str,int l1,int l2,int n)
{
if(l1>n||l2>n||l1<l2)
return;
if(l1==n&&l2==n)
{
s.push_back(str);
return;
}
fun(s,str+'(',l1+1,l2,n);
fun(s,str+')',l1,l2+1,n);
return;
}
}
10.合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入: [ 1->4->5, 1->3->4, 2->6 ] 输出: 1->1->2->3->4->4->5->6
ps:可以试试最大堆排序或者优先队列，时间复杂度为nlogk 或者
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
if(lists.size()==0)
return NULL;
if(lists.size()==1)
return lists[0];
if(lists.size()==2)
return merge(lists[0],lists[1]);
int mid = lists.size()/2;
vector<ListNode*> sub_list1;
vector<ListNode*> sub_list2;
for(int i = 0;i<mid;i++){
sub_list1.push_back(lists[i]);
}
for(int i = mid;i<lists.size();i++){
sub_list2.push_back(lists[i]);
}
return merge(mergeKLists(sub_list1),mergeKLists(sub_list2));
}
ListNode *merge(ListNode* l1,ListNode *l2){
if(!l1)
return l2;
if(!l2)
return l1;
if(l1->val<=l2->val)
{
l1->next=merge(l1->next,l2);
return l1;
}
else
{
l2->next=merge(l1,l2->next);
return l2;
}
}
};
11.给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
if(!head)
return NULL;
if(head->next==NULL)
return head;
ListNode* l=head->next;
head->next=l->next;
l->next=head;
head->next=swapPairs(head->next);
return l;
}
};
12.给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
示例 :
给定这个链表：1->2->3->4->5
当 k = 2 时，应当返回: 2->1->4->3->5
当 k = 3 时，应当返回: 3->2->1->4->5
class Solution {
public:
ListNode* reverseKGroup(ListNode* head, int k) {
stack<ListNode *> s;
ListNode *r,*p,*h;
ListNode *l1=new ListNode(0);
ListNode *l2=l1;
while(1)
{
h=head;
for(int i=0;i<k&&head;i++,head=head->next)
s.push(head);
if(s.size()==k)
{
r=s.top();
s.pop();
p=r;
while(!s.empty())
{
p->next=s.top();
s.pop();
p=p->next;
}
l2->next=r;
l2=p;
}
else
break;
}
l2->next=h;
return l1->next;
}
};
13.给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if (nums.size() < 2)
return nums.size();
int j = 0;
for (int i = 1; i < nums.size(); i++)
if (nums[j] != nums[i])
nums[++j] = nums[i];
return ++j;
}
};
14.给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度,不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:
给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
if(nums.size()<1)
return 0;
int j=-1;
for(int i=0;i<nums.size();i++)
if(nums[i]!=val)
nums[++j]=nums[i];
return ++j;
}
};
15.给定一个字符串 s 和一些长度相同的单词 words。找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。
注意子串要与 words 中的单词完全匹配，中间不能有其他字符，但不需要考虑 words 中单词串联的顺序。
示例 1：
输入： s = "barfoothefoobarman", words = ["foo","bar"] 输出：[0,9] 解释： 从索引 0 和 9 开始的子串分别是 "barfoor" 和 "foobar" 。 输出的顺序不重要, [9,0] 也是有效答案。
示例 2：
输入： s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"] 输出：[]
class Solution {//我自己写的垃圾代码
public:
vector<int> findSubstring(string s, vector<string>& words) {
unordered_map<string,int> m;
vector<int> res;
if(s.empty()||words.empty())
return res;
int sum=0,k=0,s_sum=0,each_k=words[0].length();
for(int i=0;i<words.size();i++)
m[words[i]]=i+1;
for(int i=0;i<words.size();i++)
sum+=m[words[i]];
k=words.size()*each_k;
for(int i=0;i<=s.length();i++)
{
s_sum=0;
int j=0;
for(j=i;j<k+i;j+=each_k)
{
int t=0;
if(!(t=m[s.substr(j,each_k)]))
break;
else
s_sum+=t;
}
if(s_sum==sum&&j-i==k)
res.push_back(i);
}
return res;
}
};
16.给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5 输出: 2
示例 2:
输入: [1,3,5,6], 2 输出: 1
示例 3:
输入: [1,3,5,6], 7 输出: 4
示例 4:
输入: [1,3,5,6], 0 输出: 0
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
int i;
int k=nums.size();
for(i=0;i<k;i++)
if(nums[i]>=target)
break;
return i;
}
};
17.报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：
- 1
- 11
- 21
- 1211
- 111221
1 被读作 "one 1" ("一个一") , 即 11。 11 被读作 "two 1s" ("两个一"）, 即 21。 21 被读作 "one 2", "one 1" （"一个二" , "一个一") , 即 1211。
给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。
注意：整数顺序将表示为一个字符串。
示例 1:
输入: 1 输出: "1"
class Solution {
public:
string countAndSay(int n) {
string s="1";
stack<char> sta;
for(int i=1;i<n;i++)
{
string answer;
int k=s.size();
for(int j=0;j<k;j++)
{
if(!sta.empty()&&s[j]!=sta.top())
{
answer+=sta.size()+'0';
answer+=sta.top();
while(!sta.empty()) sta.pop();
}
sta.push(s[j]);
}
if(!sta.empty())
{
answer+=sta.size()+'0';
answer+=sta.top();
while(!sta.empty()) sta.pop();
}
s=answer;
}
return s;
}
};
18.给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例:
输入: [-2,1,-3,4,-1,2,1,-5,4], 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
/*
f(n):=max(f(n-1),nums[n]+f(n-1))
求取最大的一个f(n)就是
即若f(n-1)为负数则不划算
*/
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int res=nums[0];
int sum=0;
for (int i=0;i<nums.size();i++)
{
if (sum>0)
sum+=nums[i];
else
sum=nums[i];
res=max(res,sum);
}
return res;
}
};
19.给定一个仅包含大小写字母和空格 ' ' 的字符串，返回其最后一个单词的长度。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指由字母组成，但不包含任何空格的字符串。
示例:
输入: "Hello World" 输出: 5
class Solution {
public:
int lengthOfLastWord(string s) {
int k=0;
for(int i=s.size()-1;i>=0;i--)
{
if(s[i]!=' ')
k++;
else
if(k) return k;
}
return k;
}
};
20.给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1:
输入: [1,2,3] 输出: [1,2,4] 解释: 输入数组表示数字 123。
示例 2:
输入: [4,3,2,1] 输出: [4,3,2,2] 解释: 输入数组表示数字 4321。
class Solution {
public:
vector<int> plusOne(vector<int>& digits) {
for(int i=digits.size()-1;i>=0;i--)
{
if(digits[i]==9)
digits[i]=0;
else
return (digits[i]++,digits);
}
vector<int> res(digits.size()+1);
res[0]=1;
return res;
}
};
