LeetCode 2道简单算法题分享

LetCode 2道简单算法题分享
1，如何在 IDEA 上刷算法题[理性摸鱼]
1.1，安装插件
IDEA 安装插件 leetcode editor【File-Setting-Plugins-Marketplace-输入leetcode editor-安装，重启IDEA】
1.2，其他步骤
然后在一个项目里[最好专门新建个项目，用来刷算法题]，如果你安装成功了的话，你IDEA界面的右下角会出现 leetcode 的选项卡

点击之后，会出现这样的效果

再点击齿轮形状的按钮，则会弹出如下图

图中的LoginName，Password分别是登录名以及密码，输入并Apply即可
然后回到项目中，再点击右侧 Leetcode 类似地球的按钮【登录】，登录成功即可。
2，简单做两道，看看自己多厉害？
2.1，两数之和
PS：方法一是自己写的，方法二是看了别人的解决，理解后写的，自行体会，就能感受到算法的美了。/哭笑
/
@author Zol
@description 两数之和
*/

//给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
//
// 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
//
//
//
// 示例:
//
// 给定 nums = [2, 7, 11, 15], target = 9
//
//因为 nums[0] + nums[1] = 2 + 7 = 9
//所以返回 [0, 1]
//
// Related Topics 数组 哈希表

public class TwoSumDemo {

/
方法一：for嵌套循环
解答成功: 执行耗时:64 ms,击败了36.94% 的Java用户 内存消耗:39.6 MB,击败了5.06% 的Java用户

@param nums 整数数组 nums
@param target 目标值 target
@return 目标值对应的下标
/
public static int[] forToSolution(int[] nums, int target) {
// 判空处理
if (null == nums || 1 >= nums.length) {
return null;
}
for (int a = 0; a < nums.length; a++) {
// 防止越界
if (a == (nums.length - 1)) {
break;
}
// 成功，直接返回
for (int b = (a + 1); b < nums.length; b++) {
if (target == (nums[a] + nums[b])) {
return new int[]{a, b};
}
}
}
return null;
}

/**
方法二：hash Map的键值对方式
解答成功: 执行耗时:3 ms,击败了82.90% 的Java用户 内存消耗:40 MB,击败了5.06% 的Java用户

@param nums 整数数组 nums
@param target 目标值 target
@return 目标值对应的下标
/
public static int[] mapToSolution(int[] nums, int target) {
if (null == nums || 1 >= nums.length) {
return null;
}
Map map = new HashMap<>(nums.length);
for (int i = 0; i < nums.length; i++) {
// 求出差值
int diffVal = target - nums[i];
// 以键取值
Integer respondVal = map.get(diffVal);
// 没取到，则继续
if (null != respondVal) {
return new int[]{respondVal, i};
}
// 取到，则返回
map.put(nums[i], i);
}
return null;
}

public static void main(String[] args) {
int[] nums = new int[4];
nums[0] = 6;
nums[1] = 2;
nums[2] = 11;
nums[3] = 5;
int target = 11;
// int[] resultIndexs = forToSolution(nums, target);
int[] resultIndexs = mapToSolution(nums, target);
System.out.println(“index1 = “ + resultIndexs[0]);
System.out.println(“index2 = “ + resultIndexs[1]);

}
}
2.2，整数反转
题目：
/
@author Zol
@description 整数反转
*/
//给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
//
// 示例 1:
//
// 输入: 123
//输出: 321
//
//
// 示例 2:
//
// 输入: -123
//输出: -321
//
//
// 示例 3:
//
// 输入: 120
//输出: 21
//
//
// 注意:
//
// 假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
// Related Topics 数学
我第一次解决的写法：
/
方法一：转字符集合拼接取反
解答成功: 执行耗时:15 ms,击败了5.28% 的Java用户，内存消耗:37.9 MB,击败了5.33% 的Java用户

@param x
@return
/
public static int charArrToReverse(int x) {
int resultReverse = 0;
// 符号位记录
int signBit = (x >= 0 ? 1 : -1);
// 整数位置取反
String xStr = String.valueOf(x);
if (1 >= xStr.length()) {
return x;
}
String reverseStr = “”;
char[] xChars = xStr.toCharArray();
for (int i = (xChars.length - 1); i >= 0; i—) {
if (!Character.isDigit(xChars[i])) {
continue;
}
reverseStr += xChars[i];
}
try {
resultReverse = signBit Integer.valueOf(reverseStr);
} catch (NumberFormatException nfExcep) {
resultReverse = 0;
} finally {
// 取值范围 [−231, 231 − 1] —> [−231, 231 − 1]
boolean rangeCheck = -231 <= resultReverse && resultReverse <= (231 - 1);
if (!rangeCheck) {
resultReverse = 0;
}
}
return resultReverse;
}
大神的写法：
public static int reverse(int x) {
int res = 0;
while (x != 0) {
int temp = x % 10 + res 10;
System.out.println(“temp == “ + temp);
// 最关键的一步
if ((temp - x % 10) / 10 != res) {
return 0;
}
res = temp;
System.out.println(“res == “ + res);
x /= 10;
System.out.println(“——————————————-“);
}
return res;
}
差距真的挺大的，感觉自己的算法意识不够，把问题想的简单了，但好在我自己思考并动手做了。
所以，这篇博客的意义在于：一个是大家可以理性摸鱼；二是发现不足，成长自己。








宁静致远，天道酬勤。
书上得来终觉浅，绝知此事要躬行。