LeetCode: 2529. 正整数和负整数的最大计数

正整数和负整数的最大计数

原题

给你一个按 非递减顺序 排列的数组 nums ，返回正整数数目和负整数数目中的最大值。

• 换句话讲，如果 nums 中正整数的数目是 pos ，而负整数的数目是 neg ，返回 pos 和 neg二者中的最大值。

注意：0 既不是正整数也不是负整数。

示例 1：

输入：nums = [-2,-1,-1,1,2,3]
输出：3
解释：共有 3 个正整数和 3 个负整数。计数得到的最大值是 3 。

示例 2：

输入：nums = [-3,-2,-1,0,0,1,2]
输出：3
解释：共有 2 个正整数和 3 个负整数。计数得到的最大值是 3 。

示例 3：

输入：nums = [5,20,66,1314]
输出：4
解释：共有 4 个正整数和 0 个负整数。计数得到的最大值是 4 。

提示：

• 1 <= nums.length <= 2000
• -2000 <= nums[i] <= 2000
• nums 按 非递减顺序 排列。

**进阶：**你可以设计并实现时间复杂度为 O(log(n)) 的算法解决此问题吗？

class Solution {
    public int maximumCount(int[] nums) {
      
    }
}

解题思路

1. 遍历数组，统计负数和正数的个数，最后返回其中最大值，这种方法时间复杂度为 $O(n)$。
2. 采用二分查找算法：
   • * 注意考虑数组内没有 0 的情况，故不能直接使用 0 作为中间界限。
   • 找到第一个大于等于 0 的位置，之前所有均为负整数。
   • 找到第一个大于 0 的位置，之后所有均为正整数。

普通二分查找算法实现

public class BinarySearch {
    public int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] > target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }

        return -1;
    }
}

说明

在二分查找算法中，计算中间索引时通常使用 (left + right) / 2 或 left + (right - left) / 2。这两种方式都可以得到中间索引，但是在极端情况下 (left + right) / 2 可能会超出整数表示范围，因此，为了更好地处理边界情况，推荐使用 left + (right - left) / 2 来计算中间索引。

变体 - 二分查找边界算法实现

思路

由于数组按非递减顺序排列，当我们查找 0 时：

• mid == 0：右侧可能存在 0 也可能是更大的数。我们要查找第一个符合条件的元素，故此时需要缩小右边界，使其向左边界靠拢，直到不符合循环条件。
• mid > 0：左侧可能存在 0 也可能全是更大的数，此时也需要缩小右边界。
• mid < 0：左侧可能存在 0 也可能全是更大的数，此时需要缩小左边界。

举例

public class BinarySearchBoundary {
    public int binarySearchBoundary(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (arr[mid] >= target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }

        return left;
    }
}

代码示例

class Solution {
    public int maximumCount(int[] nums) {
        int negativeCount = binarySearchBoundary(nums, 0);
        int positiveCount = nums.length - binarySearchBoundary(nums, 1);
        return Math.max(negativeCount, positiveCount);
    }

    private int binarySearchBoundary(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (arr[mid] >= target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }

        return left;
    }
}