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

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

换句话讲，如果 nums 中正整数的数目是 pos ，而负整数的数目是 neg ，返回 pos 和 neg二者中的最大值。
注意：0 既不是正整数也不是负整数。

示例 1：

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

解法一：二分查找最后一个负数的索引和第一个正数的索引：

class Solution {
public:
    int maximumCount(vector<int>& nums) {
        // 初始化最后一个负数的索引为-1，第一个正数的索引为nums.size()
        // 这是没有负数或正数时的默认索引
        int maxNegIndex = -1;
        int minPosIndex = nums.size();
        
        // 找最后一个负数的索引
        int left = 0, right = nums.size() - 1;
        while (left <= right) {
            int mid = (left + right) / 2;

            // 找到本身是负数且该数右边的数是正数或0的数
            if (nums[mid] >= 0) {
                right = mid - 1;
            // 由于需要访问nums[mid+1]，因此需要判断是否索引超出（mid + 1 != nums.size()）
            } else if (mid + 1 != nums.size() && nums[mid + 1] < 0) {
                left = mid + 1;
            // 到此，要么已经找到这样的数，要么mid已经是最后一个数（nums中全是负数）
            } else {
                maxNegIndex = mid;
                break;
            }
        }

        // 找第一个正数的索引
        left = 0;
        right = nums.size() - 1;
        while (left <= right) {
            int mid = (left + right) / 2;

            // 找到本身是正数且该数左边的数是负数或0的数
            if (nums[mid] <= 0) {
                left = mid + 1;
            // 由于需要访问nums[mid-1]，因此需要判断是否索引超出（mid != 0）
            } else if (mid != 0 && nums[mid - 1] > 0) {
                right = mid - 1;
            // 到此，要么已经找到这样的数，要么mid已经是第一个数（nums中全是正数）
            } else {
                minPosIndex = mid;
                break;
            }
        }

        int negNum = maxNegIndex + 1;
        int posNum = nums.size() - minPosIndex;

        return max(negNum, posNum);
    }
};

如果输入数组长度为n，此算法时间复杂度O（lgn），空间复杂度O（1）。

解法二：遍历数组，直接算正数和负数的数量：

class Solution {
public:
    int maximumCount(vector<int>& nums) {
        int negNum = 0;
        int posNum = 0;

        for (int i : nums) {
            if (i > 0) {
                ++posNum;
            } else if (i < 0) {
                ++negNum;
            }
        }

        return max(negNum, posNum);
    }
};

如果输入数组的长度为n，此算法时间复杂度为O（n），空间复杂度为O（1）。