leetcode刷题记录（704、896、551、217）

2019.1.16 leetcode 刷题总结

题号：704

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

我的想法：

1. 可以用Arrays.binarySearch(int[] a, int key)；该方法的具体实现的、就是用的二分查找
2. 自己手写一下二分查找

对应程序：

// java
class Solution {
    public int search(int[] nums, int target) {
        // 参数检查
		if(target < nums[0] || target > nums[nums.length-1]) {
			return -1;
		}
		// 左边界
		int left = 0;
        // 右边界
		int right = nums.length-1;
        // 左右边界中间的索引
		int index = -1;
		
		while(left <= right) {
			index = left + (right - left)/2;
			if(nums[index] > target) {
                // 向左缩小范围
				right = index - 1;
			}else if(nums[index] < target) {
                // 向右缩小范围
				left = index + 1;
			}else {
				return index;
			}
		}
		
		return -1;
    }
}

题号：896

如果数组是单调递增或单调递减的，那么它是单调的。
如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。 如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。
当给定的数组 A 是单调数组时返回 true，否则返回 false。

示例 1：
输入：[1,2,2,3]
输出：true
示例 2：
输入：[6,5,4,4]
输出：true

我的想法：

1. 本题认为只有一个数字和数字全相同的数组也是单调的
2. 开始我是这样想的：遍历数组，忽略相同的数，用后一位数减去前一位数，若差大于零，认为数组是递增的，后面的相邻的数字之差不能是小于零的，若有小于零的，直接返回false；若差小于零，认为数组是递减的，后面的相邻的数字之差不能是大于零的，若有大于零的，直接返回false。
3. 结合评论里的代码，优化了判断该数组是否是递增的逻辑：用数组的后一位减去数组的第一位数，若差是大于零的，认为是递增数组；若差是小于零的，认为是递减数组。

对应程序：

class Solution {
    public boolean isMonotonic(int[] A) {
        // 参数检查
    	if(A == null || A.length == 0) {
    		return false;
    	}
        
        if(A.length == 1) {
            return true;
        }
    	// 是否递增标志
    	boolean isUp = false;
    	int start = A[0];
    	int end = A[A.length-1];
    	
    	if(end > start) {
    		isUp = true;
    	}
    	
    	return isMonotonic(A, isUp);
    }
    // 重载该方法，传入是否递增的标志
    private boolean isMonotonic(int[] A, boolean isUp) {
    	int flag = A[0];
    	for(int i = 1; i < A.length; ++i) {
    		if(isUp) {
    			if(A[i] < flag) {
    				return false;
    			}
    		}else {
    			if(A[i] > flag) {
    				return false;
    			}
    		}
    		
    		flag = A[i];
    	}
    	
    	return true;
    }
}

题号：551

给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：
‘A’ : Absent，缺勤
‘L’ : Late，迟到
‘P’ : Present，到场
如果一个学生的出勤记录中不超过一个’A’(缺勤)并且不超过两个连续的’L’(迟到),那么这个学生会被奖赏。
你需要根据这个学生的出勤记录判断他是否会被奖赏。

示例 1:
输入: “PPALLP”
输出: True
示例 2:
输入: “PPALLL”
输出: False

我的想法：

1. 判断字符串中含有多少个A，若超过一个，返回false；否则继续判断2
2. 判断字符串中是否含有"LLL"，若含有，返回false；否则，返回true；
3. 为什么判断含有"LLL"就可以？因为若连续迟到次数比两次要多，一定包含字符串"LLL"，"LLL"是它们的最小公共字串

对应程序：

class Solution {
    public boolean checkRecord(String s) {
		if(s.indexOf('A') != s.lastIndexOf('A')) {
    		return false;
    	}
		
		if(s.contains("LLL")) {
			return false;
		}
		
		return true;
    }
}

题号：217

给定一个整数数组，判断是否存在重复元素。
如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

我的想法：

1. 将所有元素入Set，比较数组的大小和Set的大小，若不等，返回true；相等，返回false。

对应程序：

// java
class Solution {
    public boolean containsDuplicate(int[] nums) {
    	Set<Integer> set = new HashSet<>();
    	for(int num : nums) {
    		set.add(num);
    	}
    	
    	return set.size() != nums.length;
    }
}

优化：

1. 好奇试了试用List实现：将数组数据存入List中，add之前做判断，若List中存在该数字，返回true；若不存在，存入List中，如果循环结束，返回false；
2. 但执行时间特别长，我怀疑是List.contains()方法导致的，看了下源码，发现它调用另一个方法，indexOf()，indexOf()方法在判断时是要遍历数组去查找数组中是否含有该值，也就是说，你每调用一次List.contains()方法，就要遍历一次底层数组，因此执行时间特别久
3. 看了别人的提交代码，发现可以先将数组排序，在依次判断相邻两个数字是否相等，我记得之前我好像说过数组排序是个费时的操作，结果这次比上面的方法要快，先贴一下代码。
4. 有关Arrays.sort()方法，推荐看一下：Arrays.sort()的底层实现

程序：

// java
class Solution {
    public boolean containsDuplicate(int[] nums) {
		if(nums == null || nums.length == 0) {
			return false;
		}
		
		Arrays.sort(nums);
		int flag = nums[0];
		for(int i = 1; i < nums.length; ++i) {
			if(flag == nums[i]) {
				return true;
			}
			
			flag = nums[i];
		}
		
		return false;
    }
}