力扣初级算法-（第一部分：数组和字符串）

数组部分

删除排序数组中的重复项（26题）

官方题解（双指针法）

这题学习到：
1、提醒自己不要忘记极端情况的处理：
这题中如果数组长度为空，不需循环，因此直接返回0
2、注意双指针的用法，判断的比较方式

思路和复杂度见题解，代码如下：

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

买卖股票的最佳时机（122题）

题解一（官方题解一：暴力）

暴力解法时间复杂度为n^n，自己可以写一下，看一下复杂度

题解二（官方题解二：计算峰和谷）

官方题解二，可以写一下

题解三（官方题解三）

利用规则：
可以多次买入卖出，但是手中只能持一股。也就是再次买入前必须先卖出，为了寻求最大利润，只要第二天价格比第一天高，就不能错过，才能得到最大的利润。

复杂度见题解，代码如下：

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

排名第二的题解，设计贪心算法动态规划。后面学习后可以再看

旋转数组（189题）

一题三解，简单但是需要多种做法

1、官方题解一（暴力）

思路和复杂度见题解
代码如下：

class Solution {
    public void rotate(int[] nums, int k) {
        //官方题解第一种
        int temp, previous;
        for(int i = 0; i < k; i++){
            //previous有前置的意思，根据题意的话，旋转一次其实就是将最后一个位置的元素前置一下
            previous = nums[nums.length - 1];
            for (int j = 0; j < nums.length; j++){
                //将两个元素交换位置，分析就可知是怎么回事。
                //j不断变化，这样就循环往后不断交换
                temp = nums[j];
                nums[j] = previous;
                previous = temp;

            }
        }
    }
}

2、官方题解二

代码如下：

class Solution {
    public void rotate(int[] nums, int k) {
        //创建一个新的数组： int[] a = new int[长度]
        int[] a = new int[nums.length];
        for (int i = 0; i < nums.length; i++){
            //和循环队列一样，自己可以画一下，到头了就得回到第一个去。
            a[(i + k) % nums.length] = nums[i];
        }
        for (int i = 0; i < nums.length; i++){
            nums[i] = a[i];
        }
    }
}

3、官方题解四

代码如下：

class Solution {
    public void rotate(int[] nums, int k) {
        k = k % nums.length;
        //因为是三次对数组反转，所以直接写了一个反转的函数
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);

    }
    public void reverse(int[] nums, int start, int end){
        while (start < end){
            //这个判断条件自己可以想一下
            //数量为奇数时，最后相等
            //数量为偶数时，最后start变成大于end了。
            //因此进入循环的条件是start<end
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start++;
            end--;
        }
    }
}

官方题解三比较难，不好理解，看有无再看的必要

存在重复元素（217题）

1、官方题解一（暴力）

官方题解解释了这个暴力会超时（n的平方就不行了，两层循环）

2、官方题解二（排序）

知识点：
1、Arrays.sort(数组名)，实现对数组的排序
2、复杂度为排序的复杂度，如堆排序，最坏复杂度为o(nlogn)

代码如下：

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        //注意：如果比较当前元素和后面元素是否相同，确实从0开始
        //但是注意只能循环到下标倒数第二个，就比较完毕。否则越界
        for (int i = 0; i < nums.length - 1; i++){
            if (nums[i] == nums[i + 1]){
                return true;
            } 
        }
        return false;
    }
}

3、官方题解三（排序）

知识点：
1、hashmap和hashset作用相似，但是hashset不关注key对应的值，只关心各个键值，因此只存储键值，不是键值对。
2、hashset初始化：
Set set = new HashSet
hashset判断某个键值是否存在：set.contains(key名)
hashset添加键值：set.add(key名)
总的使用类似于数组。

代码如下：

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

只出现一次的数字（136题）

注意审题：
1、某个元素只出现一次以外，其余每个元素均出现两次。
2、要求算法应该具有线性时间复杂度。 希望不使用额外空间来实现

1、题解一（题解第二名：异或）

题解解释的清楚，可以学习到很多。注意，第二遍写的时候，我将i从0开始了，这时结果错误。提醒自己，出现错误一定要多分析逻辑，因为0位置已经取出，因此遍历要从下标为1开始。

关于异或：
1、自身异或，结果为0
2、与0异或，为自身
3、异或满足交换律和结合律，所以一堆异或，如果全为偶数次，那结果为0，再与剩下一个异或，结果就为剩下那个
代码如下：

class Solution {
    public int singleNumber(int[] nums) {
        for (int i = 1; i < nums.length; i++){
            nums[0] = nums[0] ^ nums[i];
        }
        return nums[0];
    }
}

2、官方题解二（哈希表）

如果空间复杂度要求不是1，正常是可以使用哈希表的，下次可以做一下哈希表解法，也是第二个解法有的。

两个数组的交集（350题）

1、题解一（官方题解1）

增加知识点：
1、哈希表定义：Map<Integer, Integer> map = new HashMap<Integer, Integer>();
2、map.getOrDefault(key, defaultValue)
当Map集合中有这个key时，就使用这个key对应的值；如果没有就使用默认值defaultValue。
3、Arrays.copyOfRange(intersection, 0, index)
用于对一个已有的数组进行截取复制，复制出一个左闭右开区间的数组。左区间包含，右区间不包含
代码如下：

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        //将nums1作为短的数组，放入哈希表。如果nums1长，就调换一下
        if (nums1.length > nums2.length){
            return intersect(nums2, nums1);
        }
        //Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int num : nums1){
            //如果哈希表中存在这个num数，就使用该key对应的值，如果没有就使用逗号后的默认值
            int count = map.getOrDefault(num, 0) + 1;
            map.put(num, count);
        }
        //还不清楚最终结果数组会是几个元素，但是最多是和（少的数组）相同的个数
        //因此在开辟数组时，就先定义为nums1的长度
        int[] intersection = new int[nums1.length];
        int index = 0;
        for (int num : nums2){
            //首先是判断有无这个key，有的话就获取个数，没有就把这个元素的个数置为0
            int count = map.getOrDefault(num, 0);
            if (count > 0){
                intersection[index] = num;
                index++;
                count--;
                if (count > 0){
                    map.put(num, count);
                }
                else{
                    map.remove(num);
                }

            }
        }
        return Arrays.copyOfRange(intersection, 0, index);
    }
}

官方题解二第二次做也未看

复习到这里

加一（66题）

1、题解（题解1）

思路（详细看题解）：
根据是否需要进位分成两种情况：（1）末尾为9（2）末尾为除9以外的其他数
模拟进位，比较巧妙：
只要+1求余数，余数不等于0，说明没有进位，直接返回。如果余数等于0，说明有进位，遍历前一个数字，加1再求余数，以此循环。如果for循环都遍历完了，说明最高位也有进位，则重新建立一个数组，初始化为0，将第一位设置为1就可以了，因为，99、999之类的数字加一为100、1000
代码如下：

class Solution {
    public int[] plusOne(int[] digits) {
        for (int i = digits.length - 1; i >= 0; i--){
            digits[i]++;
            digits[i] = digits[i] % 10;
            if (digits[i] != 0){
                return digits;
            }     
        }
        digits = new int[digits.length + 1];
        digits[0] = 1;
        return digits;
    }
}

移动零（283题）

1、题解一（第二个题解）

具体思路和复杂度见题解
代码如下：

class Solution {
    public void moveZeroes(int[] nums) {
        //极端情况：为空就不需进行遍历，所以分开直接说
        if(nums == null){
            //表示直接返回，不带任何返回参数
            return;
        }
        int j = 0;
        for(int i = 0; i < nums.length; i++){
            if(nums[i] != 0){
                nums[j++] = nums[i];
            }
        }
        //经过上面循环，j最终指向最后非零元素的下一个元素
        for(int i = j; i < nums.length; i++){
            nums[i] = 0;
        }
    }
}

官方题解二未看，这个应该需要学习

两数之和（1题）

1、题解一（官方一：暴力）

具体思路和复杂度见题解，时间复杂度过不去

2、题解二（官方三：一遍哈希表）

设计的知识点总结：
1、map.containsKey(temp)
查看名为map的哈希表中是否有名为temp的Key存在，存在为1
2、异常抛出程序：throw new IllegalArgumentException(“内容”);
目前理解是：总是需要由返回值，如果找不到两个数就无法返回正常结果。就抛出一个异常：i,l,l，第一个大写
具体思路和复杂度见题解
代码如下：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for(int i = 0; i < nums.length; i++){
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                return new int[] {map.get(temp), i};
            }
            else {
                map.put(nums[i], i);
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

官方题解二未看，是两遍哈希表

旋转图像（48题）

1、题解一（官方一）

（1）思路：
通过进行元素分析，可得a[i][j]=a[j][n-i-1]。
为了在循环中实现，需要分步处理，因为双重循环的一个下标是固定的。
步骤1：先转置，即a[i][j]=a[j][i]
步骤2：将a[j][i]转到a[j]a[n-i-1]处。分成奇偶的矩阵大小，就可以判断出循环条件。
（2）小知识点：矩阵的维度获取：matrix.length

代码如下：

class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;

    // transpose matrix
    for (int i = 0; i < n; i++) {
      for (int j = i; j < n; j++) {
        int tmp = matrix[j][i];
        matrix[j][i] = matrix[i][j];
        matrix[i][j] = tmp;
      }
    }
    // reverse each row
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n / 2; j++) {
        int tmp = matrix[i][j];
        matrix[i][j] = matrix[i][n - j - 1];
        matrix[i][n - j - 1] = tmp;
      }
    }
  }
}

官方题解二、三遭到较多批判，可以寻求更优解法

字符串部分

反转字符串（344题）

1、题解一（官方三：双指针法）

和数组的反转是相似的，也是利用左右两个指针，进行相应位置的交换。官方解法二的递归解法也是需要两个指针的。

代码如下：

class Solution {
    public void reverseString(char[] s) {
        int left = 0, right = s.length - 1;
        while (left < right) {
            char tmp = s[left];
            s[left++] = s[right];
            s[right--] = tmp;
        }
    }
}

官方题解二、三遭到较多批判，可以寻求更优解法

整数反转（7题）

1、题解1（官方二：数学思路）

（1）如果不考虑溢出，是非常简单的。为了解决溢出，思路一是通过字符串转换加try catch的方式来解决，第二个思路是通过数学计算来解决。

（2）本题为数学思路，通过%号运算，从后到前取出每一位，并循环求和。看和是否>最大值或者<最小值。具体可看题解，提供了很完整的思路。对应有的判断条件进行了一个小小的转换。

（3）知识点：
java int 类整数的最大值是 2 的 31 次方 - 1 = 2147483648 - 1 = 2147483647

可以用 Integer.MAX_VALUE 表示它，即 int value = Integer.MAX_VALUE;

代码如下：

class Solution {
    public int reverse(int x) {
        int ans = 0;
        while (x != 0){
            int pop = x % 10;
            if (ans > Integer.MAX_VALUE / 10 || (ans == Integer.MAX_VALUE / 10 && pop > 7))
                return 0;
            if (ans < Integer.MIN_VALUE / 10 || (ans == Integer.MIN_VALUE / 10 && pop < -8))
                return 0;
            ans = ans * 10 + pop;
            x /= 10;
        }
        return ans;
    }
}

上面这个解法直接写出了最大值和最小值的个位上的数字，我们可以进行一个优化，即pop > Integer.MAX_VALUE % 10和pop < Integer.MIN_VALUE % 10（注意求负数个位数时，取余直接得到负的个位数，-8）。优化后的代码如下：

class Solution {
    public int reverse(int x) {
        int ans = 0;
        while (x != 0){
            int pop = x % 10;
            if (ans > Integer.MAX_VALUE / 10 || (ans == Integer.MAX_VALUE / 10 && pop > Integer.MAX_VALUE % 10))
                return 0;
            if (ans < Integer.MIN_VALUE / 10 || (ans == Integer.MIN_VALUE / 10 && pop < Integer.MIN_VALUE % 10))
                return 0;
            ans = ans * 10 + pop;
            x /= 10;
        }
        return ans;
    }
}

字符串中的第一个唯一字符（387题）

题解（官方：哈希表）

1\哈希表的思路很简单，就是先遍历一遍，把每个字符的对应个数都存好。然后再遍历一遍，取出字符对应个数为1的那个字符。
2、之前做过很类似的数字题，所以这里需要增加的主要是字符串的一些知识：
（1）单个字符类型定义：Character，字符串定义：String
（2）数组长度为nums.length，字符串长度为s.length，是一个方法。
（3）取出字符串索引i处的字符的方法为：s.charAt(i)

代码如下：

class Solution {
    public int firstUniqChar(String s) {
        Map<Character, Integer> map = new HashMap<Character, Integer>();
        int n = s.length();
        //构建哈希表：字符和对应个数放进去
        for (int i = 0; i < n; i++){
            //取出字符串s中索引i处的对应字符c
            char c = s.charAt(i);
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        for (int i = 0; i < n; i++) {
            if(map.get(s.charAt(i)) == 1)
                return i;
        }
        return -1;
    }
}

有效的字母异位词（242题）

字母异位词：字母个数相同，所含字母一样，但是位置不同。

1、题解1（官方题解一：排序）

新增知识点：
（1）将字符串转换为数组：
char[] str1 = s.toCharArray()
（2）数组操作：
Arrays.sort(str1)（排序）
Arrays.equals(str1, str2)（比较两个数组是否相等）

代码如下：

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1, str2);
    }
}

只做了解法一，解法二为哈希表，需要再做

验证回文串（125题）

1、题解1（官方题解一：筛选加判断）

1、思路：
对字符串进行一次遍历，将其中的字母和数字字符进行保留，放入另一个字符串sgood。然后判断sgood是否是普通回文串即可。
2、新增知识点（较多）：
（1）在java中定义字符串：
StringBuffer sgood = new StringBuffer();
注：不是String类型，java中String类型只要修改就会重新占据空间，不适用于需要经常修改的字符串。常用的是StringBuffer，它是线程安全的。
（2）Character.isLetterOrDigit(ch)：判断ch是否为字母或者数字字符；
sgood.append(ch)：将ch存入sgood字符串中；
Character.toLowerCase(ch)：将ch变成小写字母
sgood.toString().equals(sgood_rev.toString())：比较两个字符串是否相等
sgood.reverse()：将sgood字符串进行翻转

代码如下：

class Solution {
    public boolean isPalindrome(String s) {
        StringBuffer sgood = new StringBuffer();
        int n = s.length();
        for (int i = 0; i < n; i++) {
            char ch = s.charAt(i);
            //isLetter判断是否为字母，isDigit判断是否为数字
            if (Character.isLetterOrDigit(ch)) {
                //toLowerCase将字符转换为小写
                sgood.append(Character.toLowerCase(ch));
            }
        }
        StringBuffer sgood_rev = new StringBuffer(sgood).reverse();
        return sgood.toString().equals(sgood_rev.toString());
    }
}

解法二为常用的双指针，需要做

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。