LeetCode 算法 Part 1

目录

• 1. 两数之和
  • 1. 题目
  • 2.代码
    • 2.1 暴力法
    • 2.2 (优解)利用map做哈希表
  • 4. 算法用时
  • 5. 感想
• 2. 两数相加
  • 1. 题目
  • 2.代码
    • 2.1 处理各种情景 将结果集放入l1中
    • 2.2 (优解)官方解答(有修改)
  • 4. 算法用时
  • 5. 感想
• 3. 无重复字符的最长子串
  • 1. 题目
  • 2.代码
    • 2.1 利用map存储信息
    • 2.2 官方解答与方法一思想类似
  • 4. 算法用时
  • 5. 感想

1. 两数之和

1. 题目

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.代码

2.1 暴力法

2.2 (优解)利用map做哈希表

import java.util.HashMap;
import java.util.Map;

class Solution1 {
  public static void main(String[] args) {
    Solution1 solution = new Solution1();
    int[] result = solution.twoSum(new int[] {3, 2, 4}, 6);
    for (int i = 0; i < result.length; i++) {
      System.out.println(result[i]);
    }
  }

  /**
   * 暴力法
   * @param nums
   * @param target
   * @return
   */
  public int[] twoSum1(int[] nums, int target) {
    for (int i = 0; i < nums.length - 1; i++) {
      for (int j = i + 1; j < nums.length; j++) {
        if (nums[i] + nums[j] == target) {
          return new int[]{i, j};
        }
      }
    }
    throw new IllegalArgumentException("No two sum solution");
  }

  /**
   * (优解)利用map做哈希表
   * @param nums
   * @param target
   * @return
   */
  public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    for (int i = 0; i < nums.length; i++) {
      int needNumber = target - nums[i];
      if (map.containsKey(needNumber)) {
        return new int[]{map.get(needNumber), i};
      } else {
        map.put(nums[i], i);
      }

    }
    throw new IllegalArgumentException("No two sum solution");
  }
}

4. 算法用时

语言	方法	执行用时	内存消耗
Java	暴力法	5 ms	36.8 MB
Java	利用map做哈希表	23 ms	37.9 MB

5. 感想

两种方法在性能方面差很多,所以解题时多用数据结构有利于提升性能。

2. 两数相加

1. 题目

2. 两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.代码

2.1 处理各种情景 将结果集放入l1中

2.2 (优解)官方解答(有修改)

import leet.code.entity.ListNode;

/*
2. 两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution2 {
  public static void main(String[] args) {
    Solution2 solution = new Solution2();
    int[] l1Arr = new int[] {2, 4, 3};
    int[] l2Arr = new int[] {5, 6, 4};

    ListNode l1 = solution.creatLink(l1Arr);
    ListNode l2 = solution.creatLink(l2Arr);

    solution.addTwoNumbers(l1, l2);
  }

  private ListNode creatLink(int[] l1Arr) {
    if (l1Arr == null || l1Arr.length == 0) {
      return null;
    }

    ListNode head = null;
    ListNode pre = null;
    for (int i = 0; i < l1Arr.length; i++) {
      ListNode tem = new ListNode(l1Arr[i]);
      if (i == 0) {
        head = tem;
      } else {
        pre.next = tem;
      }
      pre = tem;
    }
    return head;
  }

  /**
   * 处理各种情景 将结果集放入l1中
   * @param l1
   * @param l2
   * @return
   */
  public ListNode addTwoNumbers1(ListNode l1, ListNode l2) {
    boolean carry = false;
    ListNode l1pre = null;
    ListNode result = l1;
    while (l1 != null || l2 != null || carry) {
      // l1 + l2
      int sum;
      if (l1 != null && l2 != null) {
        sum = l1.val + l2.val;
      } else if (l1 == null) {
        l1 = new ListNode(0);
        if (l1pre != null) {
          l1pre.next = l1;
        }
        if (l2 != null) {
          sum = l1.val + l2.val;
        } else {
          sum = 0;
        }
      } else {
        //l1 != null && l2 == null
        sum = l1.val;
      }
      // 处理上一次进位
      if (carry) {
        sum++;
        carry = false;
      }
      // 处理当前进位
      if (sum > 9) {
        sum -= 10;
        carry = true;
      }
      //赋值
      l1.val = sum;
      l1pre = l1;
      if (l1 != null) l1 = l1.next;
      if (l2 != null) l2 = l2.next;
    }

    return result;
  }

  /**
   * 官方解答(有修改) 优解
   * @param l1
   * @param l2
   * @return
   */
  public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    ListNode dummyHead = new ListNode(0);
    ListNode curr = dummyHead;
    int carry = 0;
    while (l1 != null || l2 != null) {
      int x = (l1 != null) ? l1.val : 0;
      int y = (l2 != null) ? l2.val : 0;
      int sum = carry + x + y;
      carry = sum / 10;
      curr.next = new ListNode(sum % 10);
      curr = curr.next;
      if (l1 != null) l1 = l1.next;
      if (l2 != null) l2 = l2.next;
    }
    if (carry > 0) {
      curr.next = new ListNode(carry);
    }
    return dummyHead.next;
  }
}

4. 算法用时

/*

语言	方法	执行用时	内存消耗
Java	处理各种情景	2 ms	44.2 MB
Java	官方解答	2 ms	44.7 MB

*/

5. 感想

两种算法相差无几,就是思考方式不同，一种是将所有可能都罗列出来，另一种是综合考虑。

3. 无重复字符的最长子串

1. 题目

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.代码

2.1 利用map存储信息

2.2 官方解答与方法一思想类似

class Solution3 {
  public static void main(String[] args) {
    Solution3 solution = new Solution3();
    System.out.println(solution.lengthOfLongestSubstring("abcabcbb"));
  }

  /**
   * 利用map存储信息
   * 记录起始位置来计算最大长度
   * @param s
   * @return
   */
  public int lengthOfLongestSubstring(String s) {
    HashMap<Character,Integer> map = new HashMap();
    int startPos = 0;
    int maxCount = 0;
    int n = s.length();
    for (int i = 0; i < n; i++) {
      char c = s.charAt(i);
      if (map.containsKey(c) && map.get(c) >= startPos) {
        startPos = map.get(c) + 1;
      }
      maxCount = Math.max(maxCount, i - startPos + 1);
      map.put(c, i);
    }
    return maxCount;
  }

  /**
   * 官方解答与方法一思想类似
   * @param s
   * @return
   */
  public int lengthOfLongestSubstring1(String s) {
    int n = s.length(), ans = 0;
    Map<Character, Integer> map = new HashMap<Character, Integer>();
    for (int j = 0, i = 0; j < n; j++) {
      if (map.containsKey(s.charAt(j))) {
        i = Math.max(map.get(s.charAt(j)), i);
      }
      ans = Math.max(ans, j - i + 1);
      map.put(s.charAt(j), j + 1);
    }
    return ans;
  }
}

4. 算法用时

语言	方法	执行用时	内存消耗
Java	利用map存储信息	11 ms	36.5 MB
Java	官方解答	11 ms	37.2 MB

5. 感想

做了前两道自然而然的想到了利用map来处理这道题，map是个好东西要适当使用。