LeetCode每日

5.20

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

一、暴力 （时间长）

int[] result=new int[2];
for(int i = 0; i < nums.length - 1 ; i++){
     for(int j=i+1;j < nums.length ; j++){
         if(nums[i]+nums[j] == target){
         result[0]=i;
         result[1]=j;
         return  result;
     }
   }
}
return  null;

二、Hash散列

//将数组的值作为键  下标作为值    遍历map的键  用给定结果去减当前的键 得到的值去map中获取
//在 3 ，2，4 -> 6  中会出现  【0，0】的错误结果
int[] temp = new int[2];
Map<Integer,Integer> map = new HashMap<>();
for(int i = 0; i < nums.length; i++){
    map.put(nums[i], i);
}
//遍历查找
for(int i = 0; i < nums.length; i++){
    int a = nums[i];
    if(map.containsKey(target - a)){
        temp[0] = i;
        temp[1] = map.get(target - a);
        return temp;
    }
}
return null;


//修改版

int[] temp = new int[2];
Map<Integer,Integer> map = new HashMap<>();
//遍历查找
for(int i = 0; i < nums.length; i++){
   int a = nums[i];
   if(map.containsKey(target - a)){
        temp[0] = map.get(target - a);
        temp[1] = i;
        return temp;
    }else {//如果找不到则存进去
        map.put(nums[i], i);
    }
}
return null;

正数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。 
示例 1:     输入: 123       输出: 321
示例 2:     输入: -123      输出: -321
示例 3:     输入: 120       输出: 21
注意: 
  假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。
  请根据这个假设，如果反转后整数溢出那么就返回 0。

    public int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            int pop = x % 10;
//取模就获得最后一位   
            x /= 10;
//弹出最后一位
            if (rev > Integer.MAX_VALUE/10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
//判断正数最大
            if (rev < Integer.MIN_VALUE/10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
//判断负数最大
            rev = rev * 10 + pop;
        }
        return rev;
    }

衍生出来的题目

1. 回文数

 

两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)     输出：7 -> 0 -> 8        原因：342 + 465 = 807

 

• 将当前结点初始化为返回列表的哑结点。
• 将进位 carrycarry 初始化为 00。
• 将 pp 和 qq 分别初始化为列表 L1 和 L2 的头部。
• 遍历列表 L1 和 L2 直至到达它们的尾端。

  • 将 x 设为结点 p 的值。如果 p 已经到达 L1 的末尾，则将其值设置为 0。
  • 将 y 设为结点 q 的值。如果 q 已经到达 L2 的末尾，则将其值设置为 0。
  • 设定 sum = x + y + carry。
  • 更新进位的值，carry = sum / 10。
  • 创建一个数值为 (summod10) 的新结点，并将其设置为当前结点的下一个结点，然后将当前结点前进到下一个结点。
  • 同时，将 p 和 q 前进到下一个结点。

• 检查 carry = 1 是否成立，如果成立，则向返回列表追加一个含有数字 1 的新结点。
• 返回哑结点的下一个结点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    ListNode dummyHead = new ListNode(0);
        ListNode p = l1, q = l2, curr = dummyHead;
        int carry = 0;
        while (p != null || q != null) {
            int x = (p != null) ? p.val : 0;
            int y = (q != null) ? q.val : 0;
            int sum = carry + x + y;
            carry = sum / 10;
            curr.next = new ListNode(sum % 10);
            curr = curr.next;
            if (p != null) p = p.next;
            if (q != null) q = q.next;
        }
        if (carry > 0) {
            curr.next = new ListNode(carry);
        }
        return dummyHead.next;
    }
}