LeetCode二则

不使用任何内建的哈希表库设计一个哈希集合（HashSet）。

实现 MyHashSet 类：

void add(key) 向哈希集合中插入值 key 。
bool contains(key) 返回哈希集合中是否存在这个值 key 。
void remove(key) 将给定值 key 从哈希集合中删除。如果哈希集合中没有这个值，什么

输入：
["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "remove", "contains"]
[[], [1], [2], [1], [3], [2], [2], [2], [2]]
输出：
[null, null, null, true, false, null, true, null, false]

解释：
MyHashSet myHashSet = new MyHashSet();
myHashSet.add(1);      // set = [1]
myHashSet.add(2);      // set = [1, 2]
myHashSet.contains(1); // 返回 True
myHashSet.contains(3); // 返回 False ，（未找到）
myHashSet.add(2);      // set = [1, 2]
myHashSet.contains(2); // 返回 True
myHashSet.remove(2);   // set = [1]
myHashSet.contains(2); // 返回 False ，（已移除）
0 <= key <= 106
最多调用 1000000 次 add、remove 和 contains

//并没有利用哈希表的特性，而是采用了数组的方式，使时间、空间资源消耗都比较大
class MyHashSet {
        Integer value[] = new Integer[100001];
        int size = 0;

        public MyHashSet() {
            value = new Integer[100001];
            size = 0;
        }

        public void show() {
            for (int i = 0; i < size; i++) {
                System.out.print(value[i] + " ");
            }
            System.out.println();
        }

        public void add(int key) {
            if (!contains(key)) {
                value[size] = key;
                size++;
            }
        }

        public void remove(int key) {
            int length = size;
            for (int i = 0; i < length; i++) {
                if (value[i] != null) {
                    if (value[i] == key) {
                        value[i] = null;
                        size--;
                    }
                }
                if (value[i] == null) {
                    value[i] = value[i + 1];
                    value[i + 1] = null;
                }
            }
        }

        public boolean contains(int key) {
            //双向遍历
            for (int i = 0; i <= size - 1 - i; i++) {
                if (value[i] == key || value[size - 1 - i] == key) {
                    return true;
                }
            }
            return false;
        }
    }

class MyHashSet {
        //存储数据的数组
        Integer values[];
        //哈希表的大小
        int size = 1001;
        //由于我们使用整数除法作为哈希函数，为了尽可能避免冲突，我们需要设置一个质数作为哈希表的大小
        int length = 100013;

        public MyHashSet() {
            values = new Integer[length];
        }

        //哈希函数
        private int hash(int key) {
            return key % size;
        }

        public void show() {
            for (int i = 0; i < size; i++) {
                if (values[i] != null) {
                    System.out.print("Index "+i+" :"+values[i]);
                }
            }
            System.out.println();
        }

        public void add(int key) {
            int index = hash(key);
            while (values[index] != null && !values[index].equals(key)) {
                index = (index + 1) % size;
            }
            //开放寻址法处理冲突
            values[index] = key;
        }

        public void remove(int key) {
            int index = hash(key);
            while (values[index] != null) {
                if (values[index].equals(key)) {
                    values[index] = null;
                    return;
                }
                index = (index + 1) % size;
            }
        }

        public boolean contains(int key) {
            //双向遍历
            int index = hash(key);
            while (values[index] != null) {
                if (values[index].equals(key)) {
                    return true;
                }
                index = (index + 1) % size;
            }
            return false;
        }
    }

2342. 数位和相等数对的最大和
给你一个下标从 0 开始的数组 nums ，数组中的元素都是 正 整数。请你选出两个下标 i 和 j（i != j），且 nums[i] 的数位和 与  nums[j] 的数位和相等。

请你找出所有满足条件的下标 i 和 j ，找出并返回 nums[i] + nums[j] 可以得到的 最大值 。

示例 1：
输入：nums = [18,43,36,13,7]
输出：54
解释：满足条件的数对 (i, j) 为：
- (0, 2) ，两个数字的数位和都是 9 ，相加得到 18 + 36 = 54 。
- (1, 4) ，两个数字的数位和都是 7 ，相加得到 43 + 7 = 50 。
所以可以获得的最大和是 54 。

示例 2：
输入：nums = [10,12,19,14]
输出：-1
解释：不存在满足条件的数对，返回 -1 。

提示：
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9

    /**
     * @author XiSoil
     * @date 2024/04/14 16:18
     *执行分布用时52ms,击败的35.10%Java用户
     *消耗内存分布61.39MB,击败的26.44%Java用户
     **/
    public int maximumSum(int[] nums) {
        int maxSum = -1;
        HashMap<Integer, Integer> map = new HashMap<>();
        //<数位和, 数值>
        for (int num : nums) {

            int digitSum = calculateDigitSum(num);

            if (map.containsKey(digitSum)) {
                maxSum = Math.max(maxSum, map.get(digitSum) + num);
                //更新最大值
                map.put(digitSum, Math.max(map.get(digitSum), num));
                //更新最大值
            } else {
                map.put(digitSum, num);
            }

        }
        return maxSum;
    }

    private int calculateDigitSum(int num) {
        int sum = 0;
        while (num > 0) {
            sum += num % 10;
            num /= 10;
        }
        return sum;
    }
}

/**
 * @author XiSoil
 * @date 2024/04/14 16:28
 *执行分布用时24ms,击败的83.17%Java用户
 *消耗内存分布54.54MB,击败的61.54%Java用户
 **/
    public int maximumSum(int[] nums) {
        int result = -1;
        int[] maxSum = new int[82];
        //位数和不可能超过81，所以可以用一个长度为82的数组来存储最大的位数和对应的最大值
        for (int num : nums) {
            int digitSum = calculateDigitSum(num);
            if (maxSum[digitSum] > 0) {
                result = Math.max(result, maxSum[digitSum] + num);
                //当前最大值和遍历到的值与其对应位数和相等的值比较，取最大值
            }
            maxSum[digitSum] = Math.max(maxSum[digitSum], num);
            //把当前值和对应位数和相等的值比较，取最大值
        }
        return result;
    }

    private int calculateDigitSum(int num) {
        int sum = 0;
        while (num > 0) {
            sum += num % 10;
            num /= 10;
        }
        return sum;
    }
}