力扣刷题笔记——— 两数之和(简单）和整数反转（上）

力扣第一周

第一题：

两数之和：

第一题自己第一次敲出的代码：及其错误原因分析，引以为鉴

/*
 * #1 两数之和
 */
package leetcode.daily;

public class Daily0
{

	class Solution
	{
	    public int[] twoSum(int[] nums, int target) 
	    {
			
	    	for(int i=0;i<nums.length;i++)
	    	{
	    		if (target<nums[i])
	    			continue;
	    		//上两行代码，此处比照正确题解多了这个检验目标值是否小于数组中的当前值 ，如果是当前数大于目标值，直接跳过
	    		//因为想的是 如果target=5，小于数组里的nums[i]=8，就不用寻找nums[j]了，凑不出来 target=nums[i]+nums[j];
	    		//此处显然是没有认真读题，且自以为是造成的误判，代码思路也错了
	    		//由此得出，审题时一定要注意判别，题目给出的是纯 整数 数组，还是纯正数数组，这是很关键的
	    		//例如如果此处 target=-8，num[i]=-5；那么显然 nums[i]>target，但是程序却跳过了！
				/*
				 * 32 / 55 个通过测试用例 状态：解答错误 提交时间：4 天前 最后执行的输入： [-1,-2,-3,-4,-5] -8
				 */
	    		if(target>=nums[i])
	    		{
	    			for(int j=i+1;j<nums.length;j++)
	    			{
	    				if(nums[i]+nums[j]==target){return new int[] {i,j};}
	    			}
	    		}
	    	}
			return  new int[0] ;
			//此处的两个返回值 return 之后的new 用的极为巧妙。此处掌握学习了JAVA关于方法的返回值是数组的新知识。
			

	    }
	}

}

本次刷第一题学到的东西：

//            0：当返回值是数组是，原来是可以直接return new的
//            1：不但可以new，而且new的门道有很多，
//                1.1 例如静态 new : int[] a =new int[5];
//                数组是个容器，当声明开辟数组之后，数组的长度是无法改变的，因此这种方法是静态开辟数组！
//                例如 你在int【5】 里面的 5，直接就静态定死了：
//                1.2 动态new： int[] b =new int[] {0,1,2,3,4,5};
//                同样如上，因为数组是个容器，但是在此处声明开辟数组的时候，你的元素的个数动态的决定了数组的大小。
//                1.3 上述的动态声明开辟数组其实是可以分开的 具体简化在我之前的博客里有，链接里的大佬讲述的很生动形象。

https://blog.csdn.net/nishiwodebocai21/article/details/96484891?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163456341016780366578965%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=163456341016780366578965&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-96484891.pc_search_result_control_group&utm_term=JAVA%E6%95%B0%E7%BB%84&spm=1018.2226.3001.4187 ———————————————— 版权声明：本文为CSDN博主「小红日srs」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/m0_56164356/article/details/120835925

//            2：数组的巧妙之处，JAVA后续很多的数据是建立在数组的存储上的，本处数组名.length的方法属于是小tips了
//            3：更巧妙的是关于数组的初始化，如后续一个力扣名为加一的简单题，如999+1=1000，将四位数存在一个新数组里，
//            你可以说我直接声明一个长度为4的数组，第一位 nums[0]=1，其他的用for循环填一遍 0，属于是呆呆的傻憨憨，整型数组声明后，没填长度的自动补上0了！
//                3.1 但是注意，如果利用数组的初始化，一定不能把上述我提到的两种方法杂揉起来，
//                如：        int[] nums=new int[6]{0,2,1,4,3}; 是错误的 静态搞了长度之后，一定要填满。
//                这不合适！报错原因:如果提供了数组初始化操作，则不能定义维表达式

 

此处再赘述一下很关键的小细节；

return new int[0];

官方给出的标准解法最后 加上了一句 ，相信会有老铁看到这里一头雾水的呀。
下面对于空数组的理解，借鉴一下另外一篇文章：
Java中长度为0的数组与null的区别
现有如下两个变量定义：
 

1、int[] zero = new int[0];
2 、int[] nil = null; 

上面这两种定义有什么区别呢？
zero是一个长度为0的数组，我们称之为“空数组”。空数组也是一个对象，只是包含元素个数为0。
nil是一个数组类型的空引用。
假设一个方法返回一个数组，如果它返回null，则调用方法必须先判断是否返回null，才能对放回数组进一步处理。而如果返回空数组，则无须null引用检查。
鉴于此，返回数组的方法在没有结果时，我们通常返回空数组，而不是null，这样做对于函数调用者的处理比较方便。
后记：
这边因为考虑到函数调用者处理的便捷性，使用的int[] zero = new int[0];空数组定义和赋值方式，返回空数组。

 

力扣第一题正确解答：

public class SolutionReview0
{
	public int[] twoNumsAdd(int[] nums,int target)
	{
		int len=nums.length;
		for(int i=0;i<len;i++)
		{
			for(int j=i+1;j<len;j++)
			{
				if(nums[i]+nums[j]==target)
					return new int [] {i,j};
			}
		}
		return new int[1];
	}
}

第二题：

整数反转：

第二题自己第一次看到题目写出来的代码：

 卡在了样例 最大数 最小数 乘以十，加上末位数的反转的最后一步，实际上这个是考验核心思想和数学理论的重要一步，最后四个样例没RUN过去属于考虑不周了。

我的第一次错误的源代码：

class Solution
{
    public int reverse(int x) 
	
	{
		int left=-(int)Math.pow(2,31);
		int right=-(int)(1-Math.pow(2, 31));
		if(x==0||x>right||x<left)
			return 0;
		else if(x<0)
				return -doi(-x);
			 else
				return doi(x);
	}
	public int doi(int x)
	{
		int xl=(x+"").length();
		//判定最后一位数是不是0，防止颠倒过来,举例不止120，如果是1200呢？
		boolean flag=true;
		while(flag)
		{
			if(x%10==0)
			{
				x=x/10;
				xl=xl-1;
			}
			if(x%10!=0)
				flag=false;
		}
		
		int arr[]=new int[10];
		for(int i=0;i<xl;i++)
		{
			arr[i]=x%10;
			x=x/10;
		}
//		for(int i=0;i<xl;i++)
//		{
//			System.out.println(arr[i]);
//		}
		int target=0;
		for(int j=0;j<xl;j++)
		{
			target=target+(arr[j]*(int)Math.pow(10, xl-1-j));
			
		}
		return target;
	}
}

 本题初始的想法想的较多，想的是本题的

整数反转，初始考虑较多，想的是要不要分正负，负数的符号怎么做处理，如果最后末位是一个0或者多个0的话怎么处理，如何反转

如下的代码可以实现求一串数字的长度：

	 int x=123456;
	 int len=(x+"").length();
	 System.out.println(len);

其实根本不用分析如上问题，不用知道这个数字有几位，

在Java中：

分为顺序结构和循环结构

循环结构又分为 四种

for while do while foreach、

其中 do while用的是相当少的

for和while中，大多数情况下

for需要知道具体循环的次数

while需要知道循环的终止条件

此处补充关于JAVA中循环的基础入门知识点：

break：提前结束循环，
continue：结束本躺循环

break：提前结束循环 如一个循环100次，进行到第二次 碰到break
剩下的98次不会执行

而如果是continue，则是进行到当前，立马跳过去下一次

switch 
loop   loop 指的是循环 ，break不能在除了 switch和loop外的中断

for（表达式1，表达式2，表达式3）
{
    循环体；
}

执行顺序：
1、表达式1：只执行一次。初始化。
2、判断表达式2是否为真。
3、循环体
4、表达式3；

第二趟  开始 就不走表达式1的初始化了
从表达式2开始走
2、判断表达式2是否为真。
3、循环体
4、表达式3；

如果没有表达式2 那么JAVA认为他 永远为真 
通过for循环来写一个死循环 
for（ ； ； ）
{
    循环体；
}

言归正传：在本题（第二题）可以一个while走天下！

本题举例 如数字 
x=-1 234 500
他是个负数，末尾还有0
对他进行反转，

首先 末位数 last=x%10=0
反转数 int rev=0

rev=rev*10+last;
这样如果末位数是个0
初始 

rev=0*10+0
然后还有一个0
rev=(0*10+0)*10+0
后面的两个0都不会因为反转被摆在第一位第二位

这时候该对五进行反转
-123 450 0已经经过两次除10操作，把0全部去掉了 
x=x/10两次，此时的x已经是 -12345了
然后 -12345%10==-5

last=-5(随着末位数last被除10弹出，负号也自带出来啦）
rev=0+（-5）
x=x/10=-12345/10=-1234
last=-1234%10=-4
rev=(0+-5)*10+(-4)

顺次下去，三句话完成任意整数反转 

while(x!=0)
{
    last=x%10;
    x=x/10;
    rev=rev*10+last;
}

这时候一定有小伙伴在刷第一题是对官方题解（JAVA版本）中的 Integer.MAX_VALUE一头雾水，心里想：我擦，这是个什么妖魔鬼怪。

		if(rev>Integer.MAX_VALUE||rev<Integer.MIN_VALUE)//这行代码是核心关键哦
			{
				return 0;
			}

这一定是很多好兄弟的心声，刚想明白了while循环怎么写

这怎么还要对最大值做判断捏？刚降了一个妖怎么又来了一个魔？

下面请看详解：

官方题解中给出的int 是 JAVA八大基本数据类型（八个基本数据类型，也即是 int,long,short,double,byte,float,String,boolean ）中用的比较算是最多的一个帅气的小伙伴

而他的包装类Integer和他长得截然不同

相信冲着入门JAVA这门语言来的兄弟们都对类久闻大名了，我们这里不做赘述

记得他是包装类就好

Integer类就相当于 你这个人的个体 

而Integet.MAX_VALUE相当于你的巅峰身高！200cm！

也可以理解为 c语言中的宏定义 #define MAX_VALUE 2147483647

这就够用啦~

 以下代码建议老铁们动手敲一敲，运行一下，观察观察结果哦，具体为什么是这样，

先放个图在这里呀，

其他的基本数据类型包装类有没有最大值最小值呢？

（如char，boolean）（对啦，只有 int 和char的包装类不是首字母大写呀，分别是 Integer和Character）

有了最大值最小值后，他们最大值加一和最小值减一的结果会是什么呢？~

会在后续的帖子中更新出来哦，动动小手点个关注呗~你的一键三连是对狗红日最大的支持耶！~

package the.test;
//本文档旨在测试八个基本数据类型，也即是 int,long,short,double,byte,float,String,boolean
public class Testj 
{

	public static void main(String[] args) 
	{
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MAX_VALUE+1);
		System.out.println(Integer.MIN_VALUE);
		System.out.println(Integer.MIN_VALUE-1);
		
		System.out.println(Double.MAX_VALUE);
		System.out.println(Double.MAX_VALUE+1);
		System.out.println(Double.MIN_VALUE);
		System.out.println(Double.MIN_VALUE-1);
		
		System.out.println(Long.MAX_VALUE);
		System.out.println(Long.MAX_VALUE+1);
		System.out.println(Long.MIN_VALUE);
		System.out.println(Long.MIN_VALUE-1);
		
		System.out.println(Short.MAX_VALUE);
		System.out.println(Short.MAX_VALUE+1);
		System.out.println(Short.MIN_VALUE);
		System.out.println(Short.MAX_VALUE-1);
		
		System.out.println(Byte.MAX_VALUE);
		System.out.println(Byte.MAX_VALUE+1);
		System.out.println(Byte.MIN_VALUE);
		System.out.println(Byte.MIN_VALUE-1);
		
		System.out.println(Float.MAX_VALUE);
		System.out.println(Float.MAX_VALUE+1);
		System.out.println(Float.MIN_VALUE);
		System.out.println(Float.MIN_VALUE-1);
	}

}

 第二题标准解法代码：

/*
 * 7. 整数反转
给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。
 

示例 1：

输入：x = 123
输出：321
示例 2：

输入：x = -123
输出：-321
示例 3：

输入：x = 120
输出：21
示例 4：

输入：x = 0
输出：0
 

提示：

-231 <= x <= 231 - 1
通过次数859,445提交次数2,440,949
 */
package leetcode.daily;

public class SolutionReview1 
{
	public int rev(int x)
	{
		int rev=0;
		int digit=0;
		while(x!=0)
		{
			if(rev>Integer.MAX_VALUE||rev<Integer.MIN_VALUE)//这行代码是核心关键哦
			{
				return 0;
			}
			{
				digit=x%10;
				x/=10;
				rev=rev*10+digit;
				
			}
			
		}
		
		return rev;
	}

}

其中对这两题兜兜转转使用了Math静态类内的静态方法时，发现查API是 ，在java.lang 

他就不需要进行手动导入。 大家可以多查查API啊~

需要这个小文件的老铁们动动发财的小手点一点哦~ 

需要的在评论区留言呀~