重拾刷题路02

oldmanw

已于 2022-03-27 11:47:40 修改

阅读量349

点赞数

CC 4.0 BY-SA版权

文章标签： leetcode 算法数据结构

于 2022-03-13 18:43:31 首次发布

本文链接：https://blog.youkuaiyun.com/oldmanw/article/details/123461777

本文介绍了如何利用O(1)空间复杂度和O(n)时间复杂度解决LeetCode中的MissingNumber、TwoSum等经典问题，包括数组操作、数学公式应用及高效数据结构。涉及算法有交换位置查找、哈希表查找、双指针法等，并探讨了 HappyNumber、Intersection、Palindrome等题目的多种解法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2022-03-13

268. Missing Number（Easy）

(8) Missing Number - LeetCode

要求：空间复杂度O(1)，时间复杂度O(n)

（1）交换位置：注意，在一个位置上不能只交换一次！

class Solution {
    public int missingNumber(int[] arr){
        int i = 0;
        while (i < arr.length){
            int correct = arr[i];
            if (arr[i] < arr.length && arr[i] != arr[correct]){
                swap(arr, i, correct);
            } else {
                i++;
            }
        }
        //search for missing number
        for (int index = 0; index < arr.length; index++){
            if(arr[index] != index){
                return index;
            }
        }
        return arr.length;
    }

    private void swap(int [] arr, int first, int second){
        int temp = arr[first];
        arr[first] = arr[second];
        arr[second] = temp;
    }
}

（2）1+2+...+n= n*(n+1)/2。所以用 n*(n+1)/2减去所有数字，剩下的就是缺失的那个：

class Solution {
     public int missingNumber(int[] nums) {
        int n=nums.length;
        int sum=n*(n+1)/2;
        for(int i:nums){
            sum-=i;
        }
        return sum;
    }
}

1. Two Sum（Easy）

(8) Two Sum - LeetCode

（1）双层循环

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
        result[0] = -1;
        result[1] = -1;
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    result[0] = i;
                    result[1] = j;
                    return result;
                }
            }
        }
        return result;
    }
}

（2）使用map

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int[] result = new int[2];
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < numbers.length; i++) {
            if (map.containsKey(target - numbers[i])) {
                result[1] = i;
                result[0] = map.get(target - numbers[i]);
                return result;
            }
            map.put(numbers[i], i);
        }
        return result;
    }
}

202. Happy Number（Easy）

(8) Happy Number - LeetCode

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> resultSet = new HashSet<>();
        int result = n;
        while (result != 1) {
            List<Integer> digits = new ArrayList<>();
            while (result > 0) {
                int digit = result % 10;
                result /= 10;
                digits.add(digit);
            }
            for (int digit : digits) {
                result += digit * digit;
            }
            if (resultSet.contains(result)) {
                break;
            }
            resultSet.add(result);
        }
        return result == 1;
    }
}

2022-03-20

349. Intersection of Two Arrays（Easy）

Intersection of Two Arrays - LeetCode

直接整个set就行了：

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> numSet = new HashSet<>();
        for (int num : nums1) {
            numSet.add(num);
        }
        Set<Integer> resultSet = new HashSet<>();
        for (int num : nums2) {
            if (numSet.contains(num)) {
                resultSet.add(num);
            }
        }
        int[] result = new int[resultSet.size()];
        int index = 0;
        for (int num : resultSet) {
            result[index] = num;
            index++;
        }
        return result;
    }
}

118. Pascal's Triangle（Easy）

Pascal's Triangle - LeetCode

把规则写出来就好了：

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        list.add(1);
        while (list.size() <= numRows) {
            result.add(list);
            list = buildNextLevel(list);
        }
        return result;
    }

    private List<Integer> buildNextLevel(List<Integer> upperLevel) {
        int upperSize = upperLevel.size();
        List<Integer> nextLevel = new ArrayList<>();
        for (int i = 0; i <= upperSize; i++) {
            if (i == 0 || i == upperSize) {
                nextLevel.add(1);
            } else {
                nextLevel.add(upperLevel.get(i - 1) + upperLevel.get(i));
            }
        }
        return nextLevel;
    }
}

27. Remove Element（Easy）

Remove Element - LeetCode

两个指针，一个表示判断的位置，一个表示结果的最后位置：

class Solution {
    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;
    }
}

409. Longest Palindrome（Easy）

Longest Palindrome - LeetCode

（1）构造map，存char和出现的次数：

class Solution {
    public int longestPalindrome(String s) {
        Map<Character, Integer> charNumMap = new HashMap<>();
        for (char c : s.toCharArray()) {
            if (charNumMap.containsKey(c)) {
                charNumMap.put(c, charNumMap.get(c) + 1);
            } else {
                charNumMap.put(c, 1);
            }
        }
        int result = 0;
        boolean hasOdd = false;
        for (Map.Entry<Character, Integer> entry : charNumMap.entrySet()) {
            int num = entry.getValue();
            if (num % 2 == 1) {
                hasOdd = true;
                result += num - 1;
            } else {
                result += num;
            }
        }
        if (hasOdd) {
            result++;
        }
        return result;
    }
}

（2）用set，存char，比（1）少一次循环：

class Solution {
    public int longestPalindrome(String s) {
        if(s==null || s.length()==0) return 0;
        HashSet<Character> hs = new HashSet<Character>();
        int count = 0;
        for(int i=0; i<s.length(); i++){
            if(hs.contains(s.charAt(i))){
                hs.remove(s.charAt(i));
                count++;
            }else{
                hs.add(s.charAt(i));
            }
        }
        if(!hs.isEmpty()) return count*2+1;
        return count*2;
    }
}

2022-03-27

292. Nim Game（Easy）

https://leetcode.com/problems/nim-game/

只要不是4的倍数，就是必定获胜的。

class Solution {
    public boolean canWinNim(int n) {
        return n % 4 != 0;
    }
}

451. Sort Characters By Frequency（Medium）

https://leetcode.com/problems/sort-characters-by-frequency/

（1）先记录出现的次数，再用TreeMap对次数排倒序，再输出

class Solution {
    public String frequencySort(String s) {
        Map<Character, Integer> charNumMap = new HashMap<>();
        for (char c : s.toCharArray()) {
            if (charNumMap.containsKey(c)) {
                charNumMap.put(c, charNumMap.get(c) + 1);
            } else {
                charNumMap.put(c, 1);
            }
        }
        Map<Integer, List<Character>> numCharMap = new TreeMap<>((o1, o2) -> o2 - o1); // 倒序
        for (Map.Entry<Character, Integer> entry : charNumMap.entrySet()) {
            int n = entry.getValue();
            char c = entry.getKey();
            if (numCharMap.containsKey(n)) {
                numCharMap.get(n).add(c);
            } else {
                List<Character> list = new ArrayList<>();
                list.add(c);
                numCharMap.put(n, list);
            }
        }
        StringBuilder builder = new StringBuilder();
        for (Map.Entry<Integer, List<Character>> entry : numCharMap.entrySet()) {
            int num = entry.getKey();
            for (char c : entry.getValue()) {
                for (int i = 0; i < num; i++) {
                    builder.append(c);
                }
            }
        }
        return builder.toString();
    }
}

（2）可以把TreeMap换成数组，下标表示出现的次数，时间复杂度会降低成O(n)：

https://leetcode.com/problems/sort-characters-by-frequency/discuss/93445/O(n)-Easy-to-understand-Java-Solution