LeetCode刷题1-50

01：两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
示例：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

• 暴力破解法

public class threeNumSum {
    public static void main(String[] args) {
        int num[] ={2,7,11,15};
        int[] ints = twoSum(num, 9);
        System.out.println(Arrays.toString(ints));
    }
    //暴力破解
    public static int[] twoSum(int[] nums, int target) {
        int res[] =new int[2];
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i]+nums[j]==target){
                    res[0]=j;
                    res[1]=i;
                }
            }
        }
        return res;
    }
}

• hash表

public class threeNumSum {
    public static void main(String[] args) {
        int num[] ={2,7,11,15};
        int[] ints = twoSum(num, 9);
        System.out.println(Arrays.toString(ints));
    }
    //哈希表实现
    public static int[] twoSum(int[] nums, int target) {
        int res[] =new int[2];
        HashMap<Integer,Integer> map = new HashMap<>();
        //用HashMap来存储数据，其中key是数组中的元素，value为数组中元素的索引值
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i],i);
        }
        for (int i = 0; i < nums.length; i++) {
           int other = target-nums[i];
           if (map.containsKey(other) && map.get(other) != i){
                res[0] = i;
                res[1] = map.get(other);
                break;
            }
        }
        return res;
    }
}

• hash表方法优化

public class threeNumSum {
    public static void main(String[] args) {
        int num[] ={2,7,11,15};
        int[] ints = twoSum(num, 9);
        System.out.println(Arrays.toString(ints));
    }
    //哈希表实现优化(少了一次存储map，代码做到简化)
    public static int[] twoSum(int[] nums, int target) {
        //int res[] =new int[2];
        HashMap<Integer,Integer> map = new HashMap<>(nums.length-1);
        //用HashMap来存储数据，其中key是数组中的元素，value为数组中元素的索引值
        for (int i = 0; i < nums.length; i++) {
            //此时说明map中存在一个key+nums[i]=target
            if (map.containsKey(target-nums[i])){
                return new int[]{map.get(target-nums[i]),i};
            }
            map.put(nums[i],i);
        }
        return new int[0];
    }
}

02：两数相加

两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

* 示例
 * 输入：l1 = [2,4,3], l2 = [5,6,4]
 * 输出：[7,0,8]
 * 解释：342 + 465 = 807.

代码示例

package com.ghl.leecode;

/**
 * 两数相加
 * 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
 * 请你将两个数相加，并以相同形式返回一个表示和的链表。
 * 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
 * 示例
 * 输入：l1 = [2,4,3], l2 = [5,6,4]
 * 输出：[7,0,8]
 * 解释：342 + 465 = 807.
 */
public class TwoNumPlus02 {
    public static void main(String[] args) {
        ListNode l13 = new ListNode(3);
        ListNode l14 = new ListNode(4, l13);
        ListNode l1 = new ListNode(2, l14);
        //=========简单构造测试数据===============
        ListNode l24 = new ListNode(4);
        ListNode l26 = new ListNode(6, l24);
        ListNode l2 = new ListNode(5, l26);
        ListNode listNode = addTwoNumbers(l1, l2);
        System.out.println(listNode);
    }

    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        return r(l1, l2, 0);
    }

    private static ListNode r(ListNode l1, ListNode l2, int add) {
        //此时代表l1,l2都到了最后一个节点且最后一位相加不超过10。即不需要再次计算
        if (l1 == null && l2 == null && add == 0){
            return null;
        }
        //此时l1或者l2到了最后节点，导致不能配合另一方计算条件，则默认为0至此计算
        int val1 = l1 == null ? 0 : l1.val;
        int val2 = l2 == null ? 0 : l2.val;
        //相对节点相加总数,add为上一位相加多出的余数
        int sum = val1 + val2 + add;
        //若对应节点相加不满足取余条件取相加结果即可，满足:取余如：7+8=15 留1把5给下一节点的相加额外值也就是add的值
        ListNode res = new ListNode(sum < 10 ? sum : sum % 10);
        //该轮计算完毕，两个链表节点后移，同时add变为sum/10 eg:15/10=1
        res.next = r(l1.next, l2.next, sum < 10 ? 0 : sum / 10);
        return res;
    }

    static class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }

        @Override
        public String toString() {
            return "ListNode{" +
                    "val=" + val +
                    ", next=" + next +
                    '}';
        }
    }
}

本篇所有题目来自于LeetCode