每日一道Leetcode

说明

题目来源：力扣（LeetCode）著作权归领扣网络所有。
链接：https://leetcode-cn.com
语言： Java

1.两数之和

1.1 题目描述

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

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

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

1.2 解题代码

class Solution {
    public int[] twoSum(int[] nums, int target) {
        if(nums == null && nums.length <= 1) {
			return null;
		}
		//定义一个map集合存放遍历的数以及差值的下标
		Map<Integer,Integer> map = new HashMap<Integer, Integer>();
		for(int i = 0; i < nums.length; i++) {
			int num = nums[i];
			if(map.containsKey(num)) {
				return new int[]{map.get(num), i};
			}
			map.put(target - num, i);
		}
		return null;
    }
}

1.3 执行结果

2.链表两数之和

2.1 题目描述

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

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

2.2 解题代码

class Solution {
  
	public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
		ListNode result = null;
		ListNode pre = null;
		ListNode temp = null;
		int sum = 0;
		boolean flag = false;
		while(l1 != null || l2 != null) {
			 sum = 0; 
			if(l1 != null) {
				sum	= l1.val;
				l1 = l1.next;
			}
			if(l2 != null) {
				sum	+= l2.val;
				l2 = l2.next;
			}
			//如果进位符为true 则结果+1
			sum = flag ? (sum+1) : sum;
			//如果两数之和大于9 则求模并且标志进位符号为true 
			if(sum > 9) {
				sum %= 10;
				flag = true;
			}else {
				flag = false;
			}
			//赋值
			temp = new ListNode(sum);
			if(pre == null) {
				result = temp; 
			}else {
				pre.next = temp;
			}
			pre = temp;
			
		}
		//如果最后一位数之和大于10 则需要再进1
		if(flag) {
			temp = new ListNode(1);
			pre.next = temp;
		}
	    return result;
    }
	
}

2.3 执行结果

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

3.1 题目描述

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

3.2 解题代码

class Solution {
    public int lengthOfLongestSubstring(String s) {
       if(s == null || s.length() == 0) {
			return 0;
		}
		if(s.length() == 1) {
			return 1;
		}
		int left = 0;
		int count = 0;
		int index = -1;
		for(int right = 1; right < s.length(); right++) {
			char c = s.charAt(right);
			//获取当前字符在不重复子串的下标位置
			index =s.substring(left, right).indexOf(c);
			//如果当前遍历字符在子串中，则让左指针在之前的基础上右移index+1位
			if(index >= 0) {
				left += index + 1;
			}
			//判断当前子串个数是否大于count 若大于则替换
			count = right - left + 1 > count ? right - left + 1: count;
		}
        return count;
    }
}

3.3 执行结果

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

4.1 题目描述

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0
示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

4.2 解题代码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
		if(nums1 == null || nums1.length == 0) {
			return findMedianSortedArrays(nums2);
		}
		if(nums2 == null || nums2.length == 0) {
			return findMedianSortedArrays(nums1);
		}
		int size = nums1.length + nums2.length;
        int[] temp = new int[size];
        int index1 = 0; 
        int index2 = 0;
        int index = 0;
        
        //依次取出两个数组的较小的数
        while(index1 < nums1.length && index2 < nums2.length) {
        	if(nums1[index1] <= nums2[index2]) {
        		temp[index] = nums1[index1];
        		index1 ++;
        	}else {
        		temp[index] = nums2[index2];
        		index2 ++;
        	}
        	index ++;
        }
        
        //当某个数组取完后 把剩下没取完的数组取完。
        if(index1 < nums1.length) {
        	System.arraycopy(nums1, index1, temp, index, nums1.length - index1);
        }else {
        	System.arraycopy(nums2, index2, temp, index, nums2.length - index2);
        }
        
        return findMedianSortedArrays(temp);
    }
	
	//求一个数组的中位数
	public double findMedianSortedArrays(int[] nums) {
		int size = nums.length;
		if(size % 2 == 0) {
        	return (nums[size/2] + nums[size/2 - 1])/2.0;
        }else {
        	return nums[size/2];
        }
	}
}

4.3 执行结果