简单算法题思路整理--数组

LeetCode–简单级别

1. 存在重复元素
给定一个整数数组，判断是否存在重复元素。如果有任意一个值在数组出现了至少两次，函数结果返回true，如果数组中的每个元素都不相同，返回false。
解题思路：
（1.）暴力法。两层循环每个数都与它后面的每个数进行比较
（2.）利用Set.或者map.目前我只尝试过set

`class Solution {
 public boolean containsDuplicate(int[] nums) {
        int len = nums.length;
        HashSet<Integer> set = new HashSet<>();
        for(int i=0;i<len;i++) {
            if(!set.add(nums[i]))return true;
        }
        return false;
    }
}`

2. 存在重复元素2.
给定一个整数数组和一个整数k，判断数组中是否存在两个不同的索引i,j使得nums[i]=nums[j]，并且i和j的差的绝对值最大为k
解题思路
（1.）暴力法。还是两层遍历。找到重复元素在判断下标的关系。
（2.）利用map。map<nums[i],i>。map的containsKey（key）.可以判断是否是重复元素
map的get（key）,可以去除value值，进行下标关系的判断。Math的abs求绝对值方法。
3. 删除排序数组中的重复项
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后的数组的新长度。**注意：**不要使用额外的数组控件，你必须在原地修改输入数组，并在使用O（1）额外空间的条件下完成。
解题思路
（1.）遍历。一旦发现相同。则移动后面的元素
（2.）快、慢指针。一旦快指针发现重复元素就跳过

public int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;
    int i = 0;
    for (int j = 1; j < nums.length; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

4.移除元素

给定一个数组nums和一个值val,需要在原地移除所有数值等于val的元素，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
解题思路：
（1.）循环遍历，遇到需要删的就移动元素。
（2.）快、满指针，当快指针只想元素是我们要=删除的元素时，快指针就跳过这时候慢指针就在后面，一旦遇到不是的就覆盖，快慢指针一起往前走。一直到快指针走到最后。新数组长度就是i。这题和上一题非常像

public int removeElement(int[] nums, int val) {
    int i = 0;
    for (int j = 0; j < nums.length; j++) {
        if (nums[j] != val) {
            nums[i] = nums[j];
            i++;
        }
    }
    return i;

5. 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。——你可以假设数组中无重复元素。
（1.）因为题目要求只返回位置。。所以。。。

public int searchInsert(int[] nums, int target) {
    for(int i = 0; i < nums.length;i++){
        if(nums[i] >= target){
            return i;
        }
    }
    return nums.length;
}

**6.**最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和
解题思路：
（1.）如果是最终的最大子序和的话，则它前面的一堆数肯定是不大于0的，后面一堆数肯定也是不大于0的。所以。需要maxsum标记当前最大子序和，sum来标记现在我的这一堆如果是负的了我就不要了让sum归零重新来。
7. 合并两个有序数组
给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。
说明:初始化 nums1 和 nums2 的元素数量分别为 m 和 n。你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
解题思路：
（1.）按归并排序的最后一步，归并来做。就是得多申请一个数组
（2.）左神讲解：既然题目中说了nums1后面有足够多的空间我就从后面开始整，从后往前覆盖。谁大，谁在数组的最后的位置。保证了数组A在合并的过程中不会被覆盖掉

8.买卖股票的最佳时机
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。
解题思路：
（1.）暴力法。找出给定数组中两个数字之间的最大差值（即，最大利润）。此外，第二个数字（卖出价格）必须大于第一个数字（买入价格）。

public class Solution {
    public int maxProfit(int prices[]) {
        int maxprofit = 0;
        for (int i = 0; i < prices.length - 1; i++) {
            for (int j = i + 1; j < prices.length; j++) {
                int profit = prices[j] - prices[i];
                if (profit > maxprofit)
                    maxprofit = profit;
            }
        }
        return maxprofit;
    }
}

（2.）一次遍历：根据图像反映出，就是找谷和峰。 我们可以维持两个变量——minprice 和 maxprofit，它们分别对应迄今为止所得到的最小的谷值和最大的利润（卖出价格与最低价格之间的最大差值）。

public class Solution {
    public int maxProfit(int prices[]) {
        int minprice = Integer.MAX_VALUE;
        int maxprofit = 0;
        for (int i = 0; i < prices.length; i++) {
            if (prices[i] < minprice)
                minprice = prices[i];
            else if (prices[i] - minprice > maxprofit)
                maxprofit = prices[i] - minprice;
        }
        return maxprofit;
    }
}

9.买卖股票的最佳时机2
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）
解题思路：
（1.）一次遍历：还是关心谷和峰，单区别于上一题，我们不是关心最低的谷和最高的峰。而是关心相邻的连续的谷和峰。将这些差相加就是总的利润。

class Solution {
    public int maxProfit(int[] prices) {
        int maxprofit = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1])
                maxprofit += prices[i] - prices[i - 1];
        }
        return maxprofit;
    }
}