LeetCode-数据结构入门-01数组

Day01 数组

太久没好好敲代码了，转眼自己大学生活也快结束了，转身回顾四年来的生活，感觉除了草草敷衍学校的课业以外，确实没有用心去认真学过什么东西，之所以打算写这个日志，意在督促自己努力学习，希望明年的这个时候，能考上研究生。
自己编程能力很差，但是就像解数学题一样，学一道知识前，应当先思考给出自己的解法和思路，方法虽然很笨但是却也是学习最效率的方法，各位大佬轻喷（官方题解均来自leetcode网站）。

01 存在重复的元素

2021/12/27
2022/7/13 复习

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

(java)
思路：暴力遍历，给定一个数组，取第一个元素，依次比较其余的元素，每比较完一遍，比较位置数加一。

class Solution {
    public boolean containsDuplicate(int[] nums) {
        boolean isDuplicate = false;
        int len = nums.length;
        int temp;
        for(int i=0; i<len; i++){
            temp = nums[i];
            for(int j=i+1; j<len ; j++)  
                if(temp == nums[j]){
                    isDuplicate = true;
                    break;
                }
        }
        return isDuplicate;
    }
}

提交超出时间限制

---

题解：
（1）排序后，相邻元素必然重复，只需遍历一遍数组；

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

（2）使用哈希表，插入一个元素后发现该元素已经存在于哈希表中，则说明存在重复的元素。

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        for (int x : nums) {
            if (!set.add(x)) {
                return true;
            }
        }
        return false;
    }
}

---

Java知识点整理

Arrays.sort()
java.util类库中提供了Arrays类，实现了一些数组常用的方法

/*
 * 采用优化的快速排序算法对数组进行排序
 * 参数a类型：int、long、short、char、byte、boolean、float、double
 */
static void sort(type[] a)

其常用的static方法还有：equals()、fill()、binarysearch()、hashCode()
HasnSet
Java中散列表用链表数组实现，每个列表称为桶，在散列表中查找某个元素时需要先计算其散列码，找到对应桶的索引，查找元素在桶中的位置；
Java用Set类表示散列表，Set是没有重复元素的集合，HashSet实现了基于散列表的集。

---

02 最大子数组之和

2021/12/28

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组 是数组中的一个连续部分。

（java）
思路：数组元素连续，意味着每加一个元素，若小于当前总和，表示不需要该元素，重新选择该元素的下一个元素作为起点；每次重新选择起点，就将当前总和加入临时数组并值为零，最后统计该数组中的最大值，即为所求最大值。

class Solution {
    public int maxSubArray(int[] nums) {
        //ArrayList<Integer> list = new ArrayList<>();
        /*
        int start,end;
        start = nums[0];
        end = nums[1];
        int sum = 0,lastSum = 0;
        for(int i=0; i<nums.length; i++){
            start = i;
            end = start + 1;
            lastSum += nums[i];
            sum += nums[i];
            if(sum)
        }
        */
        //int i = 0,start = 0,lastSum = 0,sum = 0;
        int i = 0, maxValue = 0, sum = 0, lastSum = 0;
        while(i < nums.length){
            lastSum += nums[i];
            sum += nums[i];
            i++;
            if(i != nums.length)
             sum += nums[i];

            if(lastSum > sum){
                maxValue = lastSum;
                if(i+1 != nums.length){
                    i++;
                    lastSum = sum = 0;
                }
            }         
            /*
            if(lastSum > sum){
                list.add(lastSum);
                if(i+1 != nums.length){
                    i++;
                    lastSum = sum = 0;
                }
            }
            */
        }
    return maxValue;
    }
}

虽然有思路，但是没写出来，上面的代码算是草稿吧，关键难点在于比较当前保存的总和和下一个数加入的总和进行比较，很明显能看出遍历一次就能解出，问题出在for、while循环的取舍上，想了太长时间了，先给个题解，等有时间慢慢写出自己的理解。

---

题解：
（1）动态规划，动态规划转移方程：
f(i) = max{ f(i-1) + nums[i], nums[i] }

动态规划的思路：每一次加后面的数，如果上一个数加上当前数小于等于零的话，相当于前面的部分对后面是减益效果，直接取当前段；否则加上nums[i]。

class Solution {
    public int maxSubArray(int[] nums) {
        int pre = 0, maxAns = nums[0];
        for (int x : nums) {
            pre = Math.max(pre + x, x);
            maxAns = Math.max(maxAns, pre);
        }
        return maxAns;
    }
}

---

算法知识点整理

（1）动态规划：
认真看完LeetCode上liweiwei1419大佬的解法让我学到很多，类似动态规划的题目基本思路分为四步：（1 状态定义（本题中求最大的连续子数组和，经过分析，该题实际上可以理解为求以nums[i]结尾的连续子数组最大和，其中该子状态通过有无后效性排除错误子状态定义，寻找正确子状态定义实现）；
（2 建立状态转移方程，其中上面状态转移方程还可以建立成
dp[i] = max{ nums[i] , dp[i-1] + nums[i] }
dp[i] 表示以nums[i] 结尾的连续最大子数组和，根据dp[i-1]值判断是否选取dp[i-1]，若前面的段小于等于零，直接选取nums[i] 作为新的 dp[i]，根据子状态定义的不同，建立了不同的状态方程；
（3 初始化，dp[0] = nums[0]；
（4 输出，这里输出的是子状态数组中的最大值，即以 nums[i] 结尾的连续最大子数组和的状态集中的最大值 ；
（5 是否能进行空间优化。
这里给出liweiwei1419大佬的未进行空间优化的代码：

public class Solution {

    public int maxSubArray(int[] nums) {
        int len = nums.length;
        // dp[i] 表示：以 nums[i] 结尾的连续子数组的最大和
        int[] dp = new int[len];
        dp[0] = nums[0];

        for (int i = 1; i < len; i++) {
            if (dp[i - 1] > 0) {
                dp[i] = dp[i - 1] + nums[i];
            } else {
                dp[i] = nums[i];
            }
        }

        // 也可以在上面遍历的同时求出 res 的最大值，这里我们为了语义清晰分开写，大家可以自行选择
        int res = dp[0];
        for (int i = 1; i < len; i++) {
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

（2）分治-线段树求解
待分析知识点：递归回升的方式、线段树的学习理解、LeetCode线段树问题（区间最长连续上升序列，区间最大子段和）
2022/7/31 知识点整理