整数反转
1. 问题描述
给你一个 32 位的有符号整数 x ,返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−2^31, 2^31 − 1] ,就返回 0。
假设环境不允许存储 64 位整数(有符号或无符号)。
示例 1:
输入:x = 123 输出:321 示例 2:
输入:x = -123 输出:-321 示例 3:
输入:x = 120 输出:21 示例 4:
输入:x = 0 输出:0
提示:
-2^31 <= x <= 2^31 - 1
2. 代码
int reverse(int x)
{
long n=0;//避免容器n溢出
while(x!=0)
{
n=n*10+x%10;//每次取x的个位,并把前一次的取值*10
x=x/10;//降位
}
return (int)n==n?(int)n:0;//如果n不溢出就返回整数n,否则返回0
}
两数之和
1.问题描述
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1:
输入:nums = [2,7,11,15], target = 9 输出:[0,1] 解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。 示例 2:
输入:nums = [3,2,4], target = 6 输出:[1,2] 示例 3:
输入:nums = [3,3], target = 6 输出:[0,1]
提示:
2 <= nums.length <= 103 -109 <= nums[i] <= 109 -109 <= target <= 109 只会存在一个有效答案
2.预备知识
-
//在哈希表中 it->first//键值(key) it->second//数值(value)
-
auto
auto的原理就是根据后面的值,来自己推测前面的类型是什么。
auto的作用就是为了简化变量初始化,如果这个变量有一个很长很长的初始化类型,就可以用auto代替。
3.思路
-
这道题可以使用两个循环嵌套来实现功能,但是时间复杂度O(n^2),我们可以在此基础上想到两种优化方案:1.哈希表。2.平衡二叉树。因为我们遍历不需要排序,于是选择使用哈希表来优化
-
建立哈希表,查找表中是否存在target-x即可
-
将哈希表的键值设置为nums中的值,数值为nums的下标
4.代码
c++
vector<int> twoSum(vector<int>& nums, int target)
{
unorder_map<int,int> rec;
for(int i=0;i<nums.size();i++)
{
auto j=rec.find(target-nums[i]);
if(j!=rec.end())//nums中存在j
{
return {j->second;i};
}
rec[nums[i]]=i;//nums中不存在j,则储存nums[i],并将i作为数值
}
return {};//无结果返回空
}
Java
class Solution{
public int[] twoSum(int[] nums, int target){
Map<Integer,Integer> rec=new HashMap<Integer,Integer>();
for(int i=0;i<nums.length;i++)
{
if(rec.containsKey(target-nums[i]))
{
return new int[]{rec.get(target-nums[i]),i};
}
rec.put[num[i],i];
}
return new int[0];
}
}
面向过程&面向对象
-
面向过程即为顺序编码,一步一步写下想要干的事情
-
面向对象体现分类的思想,将处理的问题分为多个类,再将这些类处理,适合处理需要多人协作的问题,以类的方式组织代码,以对象的组织(封装)数据
-
面向对象的三大特性:封装,继承,多态
-
处理复杂的事物,从宏观上把握,从整体上用面向对象的思路分析整个系统,再具体到微观操作,用面向过程的思路去处理最后的问题
Java里的小知识点
-
//和类一起加载,主函数中不创建对象都可以直接调用 public static void a(){ } //和类实例化,主函数中创建对象之后才有 public void b(){ }
-
Error通常是灾难性错误,是程序无法控制和处理的,Java虚拟机(JVM)一般会选择终止线程;Exception通常是可以被程序处理的,并在程序中尽可能去处理这些异常