C++_Leetcode刷题之路——简单（持续更新）
目录
1. 两数之和
解一：
解二：
7. 整数反转
解一：
9. 回文数
解一：
13. 罗马数字转整数
解一：
14. 最长公共前缀
解一：
20. 有效的括号
解一：
21. 合并两个有序链表
解一：
26. 删除有序数组中的重复项
解一：
27. 移除元素
解一：
28. 实现 strStr()
解一：
35. 搜索插入位置
解一：
53. 最大子序和
解一：
解二：
58. 最后一个单词的长度
解一：
66. 加一
解一：
解二：
67. 二进制求和
解一
解二
69. x 的平方根
解一：
70. 爬楼梯
解一：
83. 删除排序链表中的重复元素
解一：
88. 合并两个有序数组
解一：
解二：
94. 二叉树的中序遍历
解一：
解二：
解三：
100. 相同的树
解一：
101. 对称二叉树
解一：
解二：
解三：
104. 二叉树的最大深度
解一：
108. 将有序数组转换为二叉搜索树
解一：
110. 平衡二叉树
解一：
111. 二叉树的最小深度
解一：
解二：
解三：
112. 路径总和
解一：
118. 杨辉三角
解一：
119. 杨辉三角 II
解一：
121. 买卖股票的最佳时机
解一：
122. 买卖股票的最佳时机 II
解一：
解二：
125. 验证回文串
解一：
136. 只出现一次的数字
解一：
141. 环形链表
解一：
解二：
144. 二叉树的前序遍历
解一：
解二：
解三：
145. 二叉树的后序遍历
解一：
解二：
155. 最小栈
解一：
160. 相交链表
解一：
解二：
167. 两数之和 II - 输入有序数组
解一：
68. Excel表列名称
解一：
169. 多数元素
解一：
解二：
171. Excel 表列序号
解一：
172. 阶乘后的零
解一：
1. 两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
解一：
class Solution {
public:
vector twoSum(vector& nums, int target) {
unordered_map HashMap;
for (int i = 0; i < nums.size(); i++) {
//1.判断target-nums[i]是是否在hashmap中
//如果有，则说明找到了
//没有则将nums[i]:i键值对放入hashmap中
if (HashMap.count(target- nums[i])) {
//cout << HashMap[target - nums[i]]<< "and" << i<< endl;
return {HashMap[target - nums[i]],i};
break;
}
else {
HashMap[nums[i]] = i;
}
}
return {};
}
}; 解二：
class Solution {
public:
vector twoSum(vector& nums, int target) {
int i,j;
for(i=0;i 7. 整数反转
给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。
示例 2：
输入：x = -123
输出：-32
解一：
class Solution {
public:
int reverse(int x) {
int ans = 0;
while (x != 0) {
if (x > 0 && ans > (pow(2,31)-1 - x % 10) / 10) return 0;
if (x < 0 && ans < (-pow(2,31) - x % 10) / 10) return 0;
// x=123
// x%10=3
// x/10=12
ans = ans * 10 + x % 10;
x /= 10;
}
return ans;
}
};9. 回文数
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
示例1：
输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
解一：
class Solution {
public:
bool isPalindrome(int x) {
int ans = 0;
int y=x;
bool sign;
while (x != 0) {
if (x > 0 && ans > (pow(2,31)-1 - x % 10) / 10) return false;
if (x < 0) return false;//负数一定不是回文数
// x=123
// x%10=3
// x/10=12
ans = ans * 10 + x % 10;
x /= 10;
}
sign=(ans==y);
return sign;
}
};13. 罗马数字转整数
罗马数字包含以下七种字符: 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 的范围内。
示例 4:
输入: "LVIII"
输出: 58
解释: L = 50, V= 5, III = 3
解一：
class Solution {
private:
//hashmap，类似于python字典
unordered_map hashmap = {
{'I', 1},
{'V', 5},
{'X', 10},
{'L', 50},
{'C', 100},
{'D', 500},
{'M', 1000},
};
public:
int romanToInt(string s) {
int ans=0;
for( int i=0;i 14. 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1：
输入：strs = ["flower","flow","flight"]
输出："fl"解一：
class Solution {
public:
string longestCommonPrefix(vector& strs) {
if(!strs.size())
return "";
int length=strs[0].size();//以第一个字符串为标准
int n=strs.size();//看有多少个字符串
cout< 20. 有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
示例 2：
输入：s = "()[]{}"
输出：true解一：
class Solution {
public:
bool isValid(string s) {
unordered_map map={
{'(',1},
{'{',2},
{'[',3},
{')',4},
{'}',5},
{']',6}
};
stack st;
bool istrue=true;
for(char c:s){
int currentindex=map[c];//当前括号在map中的位置
if(currentindex>=1&¤tindex<=3){//左括号
st.push(c);//入栈
cout< 21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]解一：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
//谁比较长就返回谁
if(l1==NULL)
{
//cout<<"if(l1==NULL) l2->val:"<val<val:"<val<val < l2->val){
l1->next = mergeTwoLists(l1->next,l2);
return l1;
}else{
l2->next = mergeTwoLists(l1,l2->next);
return l2;
}
}
}; 26. 删除有序数组中的重复项
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
示例 2：
输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
解一：
class Solution {
public:
int removeDuplicates(vector& nums) {
int n=nums.size();
if(n<1)
{
return n;
}
else{
// cout< 27. 移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 2：
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
解一：
class Solution {
public:
int removeElement(vector& nums, int val) {
int len=nums.size();
int slow=0;
for(int fast=0;fast 28. 实现 strStr()
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。
说明：
当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。
对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。
示例 1：
输入：haystack = "hello", needle = "ll"
输出：2示例 2：
输入：haystack = "aaaaa", needle = "bba"
输出：-1示例 3：
输入：haystack = "", needle = ""
输出：0解一：
class Solution {
public:
int strStr(string haystack, string needle) {
//记录两个字符串的长度
int n = haystack.size(), m = needle.size();
int flag=-1;
if (m==0)
return 0;
if(m>n)
return -1;
//外循环，用于遍历haystack
for (int i = 0; i < n-m+1; i++) {
//先判断一下第一个和最后一个字母是否相同，相同再遍历，否则推出
// cout<<"i="<35. 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
示例 1:
输入: nums = [1,3,5,6], target = 5
输出: 2示例 3:
输入: nums = [1,3,5,6], target = 7
输出: 4解一：
class Solution {
public:
int searchInsert(vector& nums, int target) {
int i=0;
for(i=0;itarget)
return i;
}
return i;
}
}; 53. 最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。解一：
class Solution {
public:
int maxSubArray(vector& nums) {
int result = -pow(2,31);//为什么要定义一个这么小的数，是因为result要和新的count比较，count的值在int区间
int count = 0;
for (int i = 0; i < nums.size(); i++) {
count += nums[i]; //从第一个数开始求和，
if (count > result) { // 如果求和值比上一次求和结果更大，那么保留这次结果
result = count;
}
if (count <= 0) count = 0; // 如果count小于等于0，那么前面的累计效果对后面没有意义
}
return result;
}
}; 解二：
class Solution {
public:
int maxSubArray(vector& nums) {
int pre=0;
int ansMax=nums[0];
int x=0;
//遍历数组的新写法
for (int i=0;i 58. 最后一个单词的长度
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
示例 2：
输入：s = " fly me to the moon "
输出：4解一：
class Solution {
public:
int lengthOfLastWord(string s) {
int len=s.size();
int sign=0;
int count=0;
int i=s.size()-1;
while(i>=0&&s[i]==' '){
i--;
}//从后面开始，遍历完所有的空格
while(i>=0){
cout<66. 加一
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 2：
输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。解一：
class Solution {
public:
vector plusOne(vector& digits) {
int len = digits.size();
for(int i = len - 1; i >= 0; i-- ) {
if(digits[i] == 9) {
digits[i] = 0;
}
else {
digits[i]++;
return digits;
}
}
vector tmp(len + 1,0);
tmp[0] = 1;
return tmp;
}
}; 解二：
class Solution {
public:
vector plusOne(vector& digits) {
if (digits.size() == 0)
{
return digits;
}
if (digits.size() == 1)
{
if (digits[0] + 1 == 10)
{
digits.push_back(0);
digits[0] = 1;
}
else
{
digits[0] += 1;
}
return digits;
}
for (int i = digits.size()-1; i >=0; i--)
{
if (digits[i] + 1 == 10)
{
if (i == 0)
{
digits.push_back(0);
digits[0] = 1;
}
else
{
digits[i] = 0;
}
}
else
{
digits[i] += 1;
break;
}
}
return digits;
}
};
67. 二进制求和
给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。
示例 2:
输入: a = "1010", b = "1011" 输出: "10101"
解一
class Solution {
public:
string addBinary(string a, string b) {
//字符串是从左到右排列的
string ans;
int n = max(a.size(), b.size()), carry = 0;
int i = a.size()-1;
int j = b.size()-1;
cout<<"i:"<解二
class Solution {
public:
string addBinary(string a, string b) {
//字符串是从左到右排列的
string ans;
//对序列进行反向排列使得低位在左边
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
int n = max(a.size(), b.size()), carry = 0;
for (int i = 0; i < n; ++i) {
carry += i < a.size() ? (a.at(i) == '1') : 0;
carry += i < b.size() ? (b.at(i) == '1') : 0;
ans.push_back((carry % 2) ? '1' : '0');
carry /= 2;
}
if (carry) {
ans.push_back('1');
}
reverse(ans.begin(), ans.end());
return ans;
}
};69. x 的平方根
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 2:
输入: 8 输出: 2 说明: 8 的平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。
解一：
class Solution {
public:
int mySqrt(int x) {
int l = 0, r = x, ans = -1;
while (l <= r) {
//区间中点
int mid = l + (r - l) / 2;
//如果中点的平方太小，那么从中点的右边在取中点
if ((long long)mid * mid <= x) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return ans;
}
};class Solution {
public:
int mySqrt(int x) {
if (x == 0) {
return 0;
}
//牛顿迭代法
double C = x, x0 = x;
while (true) {
//迭代格式
double xi = 0.5 * (x0 + C / x0);
//迭代条件
if (fabs(x0 - xi) < 1e-7) {
break;
}
x0 = xi;
}
return int(x0);
}
};70. 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶
解一：
class Solution {
public:
int climbStairs(int n) {
int f0=0,f1=0,f2=1;
for(int i=1;i<=n;i++){
f0=f1;
f1=f2;
f2=f0+f1;
}
return f2;
}
};83. 删除排序链表中的重复元素
存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。
返回同样按升序排列的结果链表。
例 2：
输入：head = [1,1,2,3,3]
输出：[1,2,3]解一：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
if(!head){
return head;
}
ListNode *current=head;
while(current->next){
if(current->val==current->next->val)
{
current->next=current->next->next;
}
else{
current=current->next;
}
}
return head;
}
};88. 合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
解一：
class Solution {
public:
void merge(vector& nums1, int m, vector& nums2, int n) {
int sort[m+n];
int p1=0,p2=0;
int i=0;
while(p1nums2[p2])
sort[i++]=nums2[p2++];
else
sort[i++]=nums1[p1++];
}
for(int i=0;i 解二：
class Solution {
public:
void merge(vector& nums1, int m, vector& nums2, int n) {
for(int i=0;i 94. 二叉树的中序遍历
给定一个二叉树的根节点 root ，返回它的 中序 遍历。
示例 1：
输入：root = [1,null,2,3] 输出：[1,3,2]
解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector inorderTraversal(TreeNode* root) {
vector res;
TreeNode *predecessor = nullptr;
while (root != nullptr) {
if (root->left != nullptr) {
// predecessor 节点就是当前 root 节点向左走一步，然后一直向右走至无法走为止
predecessor = root->left;
while (predecessor->right != nullptr && predecessor->right != root) {
predecessor = predecessor->right;
}
// 让 predecessor 的右指针指向 root，继续遍历左子树
if (predecessor->right == nullptr) {
predecessor->right = root;
root = root->left;
}
// 说明左子树已经访问完了，我们需要断开链接
else {
res.push_back(root->val);
predecessor->right = nullptr;
root = root->right;
}
}
// 如果没有左孩子，则直接访问右孩子
else {
res.push_back(root->val);
root = root->right;
}
}
return res;
}
}; 解二：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector inorderTraversal(TreeNode* root) {
vector res;//可变数组
stack sta;//建立一个栈，里面存放的是元素的地址
while(root!=nullptr||!sta.empty()){
while(root!=nullptr){
sta.push(root);//左边的节点依次压入栈
root=root->left;
}//root指向null
root=sta.top();//指向最后一个左子孙
sta.pop();
res.push_back(root->val);
root=root->right;
}
return res;
}
}; 解三：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
void inorder(TreeNode* root,vector &res)
{
if(!root)
return ;
inorder(root->left,res);
//遍历到最后一个左边，把该元素压入res
res.push_back(root->val);
inorder(root->right,res);
}
vector inorderTraversal(TreeNode* root) {
vector res;//可变数组
inorder(root,res);
return res;
}
} 100. 相同的树
给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例 3：
输入：p = [1,2,1], q = [1,1,2]
输出：false解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(p==nullptr&q==nullptr)
return true;
else if(p==nullptr||q==nullptr)
return false;
else if(p->val!=q->val)
return false;
else {
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
}
};101. 对称二叉树
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \
2 2
/ \ / \
3 4 4 3
解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool isSymmetric(TreeNode* root) {
return check(root,root);
}
bool check(TreeNode *p, TreeNode *q) {
queue u;//建立一个空队列
u.push(p);u.push(q);
while(!u.empty()){
q=u.front();u.pop();
p=u.front();u.pop();
//两个都不为空
if(!p&&!q) continue;
if((!p||!q)||(p->val!=q->val)) return false;
u.push(q->left);
u.push(p->right);
u.push(q->right);
u.push(p->left);
}
return true;
}
}; 解二：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(root==nullptr)
return true;
//调用递归函数，比较左节点，右节点
return isSym(root->left,root->right);
}
bool isSym(TreeNode* right,TreeNode* left){
//递归的终止条件是两个节点都为空
//或者两个节点中有一个为空
//或者两个节点的值不相等
if(right==nullptr&&left==nullptr)
return true;
else if(right==nullptr||left==nullptr)
return false;
else if(right->val!=left->val)
return false;
//再递归的比较 左节点的左孩子 和 右节点的右孩子
//以及比较 左节点的右孩子 和 右节点的左孩子
return isSym(right->right,left->left)&&isSym(left->right,right->left);
}
};解三：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool isSymmetric(TreeNode* root) {
return check(root,root);
}
bool check(TreeNode *p, TreeNode *q) {
if (!p && !q) return true;
if (!p || !q) return false;
return p->val == q->val && check(p->left, q->right) && check(p->right, q->left);
}
};
104. 二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int maxDepth(TreeNode* root) {
if(root==nullptr)
return 0;
return max(maxDepth(root->left),maxDepth(root->right))+1;
}
};108. 将有序数组转换为二叉搜索树
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。
示例 1：
输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：
解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
TreeNode* sortedArrayToBST(vector& nums) {
return helper(nums, 0, nums.size() - 1);
}
TreeNode* helper(vector& nums, int left, int right) {
if (left > right) {
return nullptr;
}
// 总是选择任意一个中间位置的数字作为根节点
int mid = (left + right+ rand() % 2) / 2;
//root=0,left=
TreeNode* root = new TreeNode(nums[mid]);
root->left = helper(nums, left, mid - 1);
root->right = helper(nums, mid + 1, right);
return root;
}
}; 110. 平衡二叉树
给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
示例 2：
输入：root = [1,2,2,3,3,null,null,4,4]
输出：false解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool isBalanced(TreeNode* root) {
if(root==nullptr)
return true;
int sign=abs(height(root->left)-height(root->right));
cout<left)&&isBalanced(root->right);
}
int height(TreeNode* root){
if (root == NULL) {
return 0;
}
else{
return max(height(root->left),height(root->right))+1;
}
}
}; 111. 二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：2
解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;.
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int minDepth(TreeNode* root) {
if(root==nullptr)
return 0;
//1.左孩子和有孩子都为空的情况，说明到达了叶子节点，直接返回1即可
if(root->left == nullptr && root->right == nullptr) return 1;
//2.如果左孩子和由孩子其中一个为空，那么需要返回比较大的那个孩子的深度
int m1 = minDepth(root->left);
int m2 = minDepth(root->right);
//这里其中一个节点为空，说明m1和m2有一个必然为0，所以可以返回m1 + m2 + 1;
if(root->left == nullptr || root->right == nullptr) return m1 + m2 + 1;
//3.最后一种情况，也就是左右孩子都不为空，返回最小深度+1即可
return min(m1,m2) + 1;
}
};解二：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;.
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int minDepth(TreeNode* root) {
if(root==nullptr)
return 0;
if (root->left == nullptr && root->right == nullptr) {
return 1;
}
int min_depth = INT_MAX;
//如果左子树不为空，那么比较一下左子树的深
if (root->left != nullptr) {
min_depth = min(minDepth(root->left), min_depth);
}
if (root->right != nullptr) {
min_depth = min(minDepth(root->right), min_depth);
}
//只有满足两边都不为空的时候，最小深度才+1。
return min_depth + 1;
}
};解三：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;.
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int minDepth(TreeNode* root) {
if(root==nullptr)
return 0;
queue > que;
que.emplace(root, 1);
while (!que.empty()) {
TreeNode *node = que.front().first;
int depth = que.front().second;
que.pop();
if (node->left == nullptr && node->right == nullptr) {
return depth;
}
if (node->left != nullptr) {
que.emplace(node->left, depth + 1);
}
if (node->right != nullptr) {
que.emplace(node->right, depth + 1);
}
}
return 0;
}
}; 112. 路径总和
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。
叶子节点 是指没有子节点的节点。
示例 1：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool hasPathSum(TreeNode* root, int targetSum) {
if(root==nullptr)
return false;
//左右节点都为空
if(root->left==nullptr&&root->right==nullptr){
return targetSum==root->val;
}
cout<<"val:"<val<left,targetSum-root->val)||hasPathSum(root->right,targetSum-root->val);
}
}; 118. 杨辉三角
给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。
示例 1:
输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]解一：
class Solution {
public:
vector> generate(int numRows) {
vector> ret(numRows);
for(int i=0;i 119. 杨辉三角 II
给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。
示例 1:
输入: rowIndex = 3
输出: [1,3,3,1]解一：
class Solution {
public:
vector getRow(int rowIndex) {
//先生成一个杨辉三角
vector ret(rowIndex+1,1);
if(rowIndex < 2) return ret;
for(int i=1;i0;--j){
//i=2,第三行j=1,第二个元素
ret[j]=ret[j-1]+ret[j];
}
}
return ret;
}
}; 121. 买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
解一：
class Solution {
public:
int maxProfit(vector& prices) {
int inf = 1e9;
int minprice = inf, maxprofit = 0;
for (int price: prices) {
maxprofit = max(maxprofit, price - minprice);
minprice = min(price, minprice);
}
return maxprofit;
}
}; 122. 买卖股票的最佳时机 II
给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: prices = [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
解一：
class Solution {
public:
int maxProfit(vector& prices) {
int n=prices.size();
if(n<2){
return 0;
}
int dp[n][2];
// 0：持有现金
// 1：持有股票，
dp[0][0]=0;
//如果持有股票，当前拥有的现金数是当天股价的相反数，即 dp[0][1] = -prices[i]
dp[0][1]=-prices[0];
for(int i=1;i 解二：
class Solution {
public:
int maxProfit(vector& prices) {
if(prices.size()<2){
return 0;
}
int profits=0;
for(int i=1;i 125. 验证回文串
给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
说明：本题中，我们将空字符串定义为有效的回文串。
示例 1:
输入: "A man, a plan, a canal: Panama"
输出: true
解释："amanaplanacanalpanama" 是回文串
解一：
class Solution {
public:
bool isPalindrome(string s) {
string ispa;
for(char ch:s){
if(isalnum(ch)){
ispa += tolower(ch);
}
}
int i=0;int j=ispa.size()-1;
while(i136. 只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
示例 2:
输入: [4,1,2,1,2]
输出: 4解一：
class Solution {
public:
int singleNumber(vector& nums) {
//任何数与0异或运算是本身
//任何数字与本身异或是0，由于数组中只有一个元素出现一次，将所有元素异或后，成对的元素异或为0，留下的就是出现一次的元素
int ret=0;
for(int i:nums)
ret^=i;
return ret;
}
}; 141. 环形链表
给定一个链表，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
如果链表中存在环，则返回 true 。 否则，返回 false 。
示例 1：
输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。
解一：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool hasCycle(ListNode *head) {
ListNode *fast=head;
ListNode *slow=head;
//有null肯定是没环
while(fast!=NULL&&fast->next!=NULL){
slow=slow->next;//慢指针走一步，快指针走两步，如果有环的话，肯定会相遇
//fast->next!=NULL是为了保证这一行可以执行
fast=fast->next->next;
if(slow==fast){
return true;
}
}
return false;
}
};解二：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool hasCycle(ListNode *head) {
unordered_set map;
while(head!=NULL)
{
if(map.count(head)){//计算hash表中有几个这样的地址
return true;
}
map.insert(head);//把地址插入哈希表
head=head->next;
}
return false;
}
}; 144. 二叉树的前序遍历
示例 1：
输入：root = [1,null,2,3]
输出：[1,2,3]解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
void preorder(TreeNode *root, vector &res) {
if(root==nullptr){
return ;
}
res.push_back(root->val);//放入根节点
preorder(root->left,res);//放入左子树
preorder(root->right,res);//放入右子树
}
vector preorderTraversal(TreeNode* root) {
//前序遍历就是，根节点，左子树，右子树
vector res;
if(root==nullptr){
return res;
}
preorder(root, res);
return res;
}
}; 解二：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector preorderTraversal(TreeNode* root) {
//前序遍历就是，根节点，左子树，右子树
vector res;
if(root==nullptr){
return res;
}
//新建一个栈,用来存各个节点的地址
stack stk;
//循环终止条件，栈为空且,节点指向null
while(!stk.empty()||root!=nullptr){
while(root!=nullptr){
//把根节点依次压入栈
res.push_back(root->val);
stk.push(root);
root=root->left;
}
root=stk.top();//第一个读出来的是最左子树
stk.pop();//元素取出后，弹出
root=root->right;//然后去寻找她的右节点
}
return res;
}
} 解三：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector preorderTraversal(TreeNode* root) {
//前序遍历就是，根节点，左子树，右子树
vector res;
if(root==nullptr){
return res;
}
TreeNode *p1=root,*p2=nullptr;
while(p1!=nullptr){
p2=p1->left;
if(p2!=nullptr){//如果当前节点的左子节点不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点：
//p2的右节点不为空，且不等与父节点
while(p2->right!=nullptr&&p2->right!=p1){
p2=p2->right;
}
if(p2->right==nullptr){//如果前驱节点的右子节点为空，将前驱节点的右子节点设置为当前节点。
//然后将当前节点加入答案，并将前驱节点的右子节点更新为当前节点。当前节点更新为当前节点的左子节点。
res.push_back(p1->val);
p2->right=p1;
p1=p1->left;
continue;
}else{// 如果前驱节点的右子节点为当前节点，将它的右子节点重新设为空。当前节点更新为当前节点的右子节点。
p2->right=nullptr;
}
}else{//如果当前节点的左子节点为空，将当前节点加入答案
res.push_back(p1->val);
}
p1 = p1->right;//往左节点
}
return res;
}
}; 145. 二叉树的后序遍历
给定一个二叉树，返回它的 后序 遍历。
示例:
输入: [1,null,2,3]
1
\
2
/
3
输出: [3,2,1]
解一：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
//后序遍历，左右中
vector postorderTraversal(TreeNode* root) {
vector res;
if(root==nullptr)
return res;
stack stk;
TreeNode *prev = nullptr;
//循环终止条件，栈空，指针也为空
while(!stk.empty()||root!=nullptr){
while(root!=nullptr){
stk.push(root);
root=root->left;
}
//指向最左边的元素
root=stk.top();
stk.pop();
if (root->right == nullptr || root->right == prev) {
res.push_back(root->val);
prev = root;
root = nullptr;
} else {//右边不为空，那么继续往右边遍历
stk.push(root);
root = root->right;
}
}
return res;
}
}; 解二：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
void postorder(TreeNode* root,vector &res){
if(root==nullptr)
return ;
//后序遍历，左右中
postorder(root->left,res);
postorder(root->right,res);
res.push_back(root->val);
}
vector postorderTraversal(TreeNode* root) {
vector res;
if(root==nullptr)
return res;
postorder(root,res);
return res;
}
}; 155. 最小栈
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
示例:
输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]输出：
[null,null,null,null,-3,null,0,-2]解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.
解一：
class MinStack {
stack x_stack;
stack min_stack;
public:
/** initialize your data structure here. */
MinStack() {
min_stack.push(INT_MAX);
}
void push(int val) {
x_stack.push(val);
min_stack.push(min(min_stack.top(),val));
}
void pop() {
x_stack.pop();
min_stack.pop();
}
int top() {
return x_stack.top();
}
int getMin() {
return min_stack.top();
}
};
/**
* Your MinStack object will be instantiated and called as such:
* MinStack* obj = new MinStack();
* obj->push(val);
* obj->pop();
* int param_3 = obj->top();
* int param_4 = obj->getMin();
*/ 160. 相交链表
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
解一：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
if (headA == nullptr || headB == nullptr) {
return nullptr;
}
ListNode *you = headA, *she = headB;
while (you != she) { // 若是有缘，你们早晚会相遇
you = you ? you->next : headB; // 当你走到终点时，开始走她走过的路
she = she ? she->next : headA; // 当她走到终点时，开始走你走过的路
}
return you;
}
};解二：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
unordered_set map;
while(headA!=nullptr){
map.insert(headA);
headA=headA->next;
}
while(headB!=nullptr){
if(map.count(headB)){
return headB;
}
headB=headB->next;
}
return nullptr;
}
}; 167. 两数之和 II - 输入有序数组
给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例 1：
输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
解一：
class Solution {
public:
vector twoSum(vector& numbers, int target) {
int low = 0, high = numbers.size() - 1;
while (low < high) {
int sum = numbers[low] + numbers[high];
if (sum == target) {
return {low + 1, high + 1};
} else if (sum < target) {
++low;
} else {
--high;
}
}
return {-1, -1};
}; 68. Excel表列名称
给你一个整数 columnNumber ，返回它在 Excel 表中相对应的列名称。
解一：
class Solution {
public:
string convertToTitle(int columnNumber) {
string row;
while (columnNumber)
{
//columnNumber=28
//remainder=2
int remainder = columnNumber % 26;
if(remainder==0)//如果余数是0，就像上一位借个1（26）出来，让余数强行等于26
{
remainder = 26;
columnNumber -= 26;
}
//B
row.push_back(remainder+ 64);
//columnNumber=1——————A
columnNumber /= 26;
}
//BA
reverse(row.begin(), row.end());
//A
return row;
}
};169. 多数元素
给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例 2：
输入：[2,2,1,1,1,2,2]
输出：2解一：
class Solution {
public:
int majorityElement(vector& nums) {
unordered_map map;
int majority = 0, cnt = 0;
for (int num: nums) {
++map[num];//同样的数字出现一次，键值加一次
if (map[num] > nums.size()/2) {
return num;
cout<<"num:"< 解二：
class Solution {
public:
int majorityElement(vector& nums) {
//对数组进行排序，那么大于n/2的元素一定出现在n/2
sort(nums.begin(), nums.end());
return nums[nums.size() / 2];
}
}; 171. Excel 表列序号
给你一个字符串 columnTitle ，表示 Excel 表格中的列名称。返回该列名称对应的列序号。
解一：
class Solution {
public:
int titleToNumber(string columnTitle) {
int ans=0;
//先反转一下
reverse(columnTitle.begin(),columnTitle.end());
int ex=0;
for(char ch:columnTitle){
ans+=(ch-64)*pow(26,ex);
ex++;
cout<172. 阶乘后的零
给定一个整数 n，返回 n! 结果尾数中零的数量。
示例 2:
输入: 5
输出: 1
解释: 5! = 120, 尾数中有 1 个零.解一：
class Solution {
public:
int trailingZeroes(int n) {
int zero_count=0;
for(int i=1;i<=n;i++){
int N=i;
while(N>1){
if(N%5==0){
zero_count++;
N=N/5;
}else{
break;
}
}
}
return zero_count;
}
};