leetcode刷题记录(88、121、217)

88. 合并两个有序数组

我的思路：

1. 首先将nums2添加到nums1中
   1.1 方法介绍：
   arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
   参数详解：
   src：原数组。
   srcPos：原数组中的起始位置，也就是从原数组的哪一位开始拷贝。
   dest：目标数组。
   destPos：目标数据中的起始位置，也就是从目标数组的哪一个位置开始存储要拷贝的元素。
   length：要复制的数组元素的数量。
   
2. 再将nums1排序

对应程序

public void merge(int[] nums1, int m, int[] nums2, int n) {
	//1
	System.arraycopy(nums2, 0, nums1, m, n);
	//2
	Arrays.sort(nums1);
}

        虽然看起来代码很短，但是没用，用时执行用时 :2 ms, 在所有 Java 提交中击败了25.68%的用户。。。。很尴尬
        最后参考了一下人家大神的，总结了一下思路，自己写了一遍（ps：用时最短的看不懂）：

其他思路：

1. 定义三个变量，a是nums1中指向有效元素中最大的索引，b是nums2中最大的索引，top是指向nums1尾部的索引
2. 将nums1与nums2中的有效元素循环比较
   2.1.若是nums1中的值大，则将值放入nums1尾部，top–，a–
   2.2.若是nums2中的值大，则将值放入nums1尾部，top–，b–
3. 若是循环完之后，nums2中还有元素，则将全部移至nums1的头部

对应程序

public void merge(int[] nums1, int m, int[] nums2, int n) {
	//1
	int a = m-1;
	int b = n-1;
	int top = m+n-1;
	//2
	while(a>=0&&b>=0) {
		//2.1
		if(nums1[a]>nums2[b]) {
			nums1[top--] = nums1[a--];
		} 
		//2.2
		else {
			nums1[top--] = nums2[b--];
		}
	}
	//3
	if(b>=0) {
		System.arraycopy(nums2, 0, nums1, 0, b+1);
	}
}

        好了，这个题就到这了，这个题告诉我们，做题不是代码越短越好，而是要效率高。

121. 买卖股票的最佳时机

我的思路：

1. 排除特殊情况，若是只有一个元素，则直接return 0
2. 定义两个变量，min是前i天中最低的价格，最小值默认为第一个元素，max是第i天的最大利润，默认为0
3. 循环求最大利润，
   3.1. 第i天的最大利润=max{前(i-1)天的最大收益，第i天的价格 - 前(i-1)天中的最第价格}
   3.2. 前i天中最低的价格=min{前(i-1)天的最低的价格，第i天的价格}
4. 返回求得的最大利润值

对应程序

public int maxProfit(int[] prices) {
	//1
	if(prices.length<=1) {
		return 0;
	} 
	//2
	int min = prices[0],max = 0;
	//3
	for(int i=1;i<prices.length;i++) {
		//3.1
		max = Math.max(max, prices[i]-min);
		//3.2
		min = Math.min(min, prices[i]);
	}
	//4
	return max;
}

        以上就是我对这个提的思路，这个题主要是因为我在做笔试时遇到过，原先做的很差，最后下去查了查，了解了一下思路，有了以上的做法。
        而这个题的核心思想就是：
        动态规划 ：前i天的最大收益 = max{前i-1天的最大收益，第i天的价格-前i-1天中的最小价格}

217.存在重复元素

我的思路：

1. 先将特殊情况排除
   1.1 只有一个原元素则返回false
   1.2 只有两个元素，则将两个元素直接比较，看是否相等
2. 将数组进行排序
3. 循环将自身与与下一个进行比较，若有一个相等，则返回true，若循环遍历完之后也无相等，则返回false

对应程序

public boolean containsDuplicate(int[] nums) {
	//1
	//1.1
	if(nums.length == 1) {
		return false;
	} 
	//1.2
	else if(nums.length == 2) {
			return nums[0]==nums[1];
	}
	//2
	Arrays.sort(nums);
	//3
	for (int i = 0; i+1 < nums.length; i++) {
		if(nums[i] ==nums[i+1]) {
			return true;
		}
	}
	return false;
}

        上面是我对这个提的思路，在做完之后我去看看评论区，发现一个新的做法，虽然这个做法没我写的这个快，但还是让我感觉眼前一亮。解题思路如下：

其他思路：

1. 创建一个hashSet集合（利用它的不可重复性）
2. 循环遍历将需要判断的数组添加到hashSet集合中去
3. 若是添加时失败，则直接返回true
4. 若整个循环顺利结束，则返回false

对应程序

public boolean containsDuplicate(int[] nums) {
	//1
	Set<Integer> res = new HashSet<Integer>();
	//2
	for (int i : nums) {
		boolean b = res.add(i);
		//3
		if(!b) {
			return true;
		}
	}
	//4
	return false;
}

        以上就是我对这个题的全部解法，可能不是最好，但绝对是纯天然的。