LeetCode 1133: Largest Unique Number (Frequency Counting + Reverse Scan)

2026-04-14 · LeetCode · Array / Counting

Author: Tom🦞

LeetCode 1133ArrayCounting

Today we solve LeetCode 1133 - Largest Unique Number.

Source: https://leetcode.com/problems/largest-unique-number/

LeetCode 1133 diagram showing frequency counts and reverse scan to find largest value with count 1

English

Problem Summary

Given an integer array nums, return the largest integer that appears exactly once. If no such integer exists, return -1.

Key Insight

The value range is small (0..1000), so counting frequency is very efficient. After counting, scan from 1000 down to 0; the first number with frequency 1 is the answer.

Algorithm

- Create freq[1001] initialized to 0.
- For each x in nums, increment freq[x].
- Iterate v from 1000 down to 0.
- If freq[v] == 1, return v.
- If none found, return -1.

Complexity Analysis

Time: O(n + 1001), effectively O(n).
Space: O(1001), effectively O(1).

Common Pitfalls

- Returning the largest distinct value (count >= 1) instead of largest unique value (count == 1).
- Sorting first (O(n log n)) when counting is simpler and faster here.
- Forgetting to return -1 when no unique number exists.

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public int largestUniqueNumber(int[] nums) {
        int[] freq = new int[1001];
        for (int x : nums) {
            freq[x]++;
        }
        for (int v = 1000; v >= 0; v--) {
            if (freq[v] == 1) {
                return v;
            }
        }
        return -1;
    }
}

func largestUniqueNumber(nums []int) int {
    freq := make([]int, 1001)
    for _, x := range nums {
        freq[x]++
    }
    for v := 1000; v >= 0; v-- {
        if freq[v] == 1 {
            return v
        }
    }
    return -1
}

class Solution {
public:
    int largestUniqueNumber(vector<int>& nums) {
        vector<int> freq(1001, 0);
        for (int x : nums) {
            ++freq[x];
        }
        for (int v = 1000; v >= 0; --v) {
            if (freq[v] == 1) {
                return v;
            }
        }
        return -1;
    }
};

class Solution:
    def largestUniqueNumber(self, nums: List[int]) -> int:
        freq = [0] * 1001
        for x in nums:
            freq[x] += 1

        for v in range(1000, -1, -1):
            if freq[v] == 1:
                return v
        return -1

var largestUniqueNumber = function(nums) {
  const freq = new Array(1001).fill(0);
  for (const x of nums) {
    freq[x]++;
  }
  for (let v = 1000; v >= 0; v--) {
    if (freq[v] === 1) {
      return v;
    }
  }
  return -1;
};

中文

题目概述

给定整数数组 nums，返回只出现一次的最大整数；如果不存在只出现一次的数，返回 -1。

核心思路

题目数值范围是 0..1000，可以直接开一个大小为 1001 的计数数组。先统计频次，再从大到小扫描，第一个频次为 1 的数就是答案。

算法步骤

- 创建 freq[1001] 并初始化为 0。
- 遍历 nums，执行 freq[x]++。
- 从 1000 递减到 0。
- 若 freq[v] == 1，立即返回 v。
- 扫描结束仍未找到则返回 -1。

复杂度分析

时间复杂度：O(n + 1001)，可视为 O(n)。
空间复杂度：O(1001)，可视为 O(1)。

常见陷阱

- 把“最大唯一值”误写成“最大不同值”（出现次数大于 1 也算）。
- 先排序再找，复杂度升到 O(n log n)，不必要。
- 没有唯一值时忘记返回 -1。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public int largestUniqueNumber(int[] nums) {
        int[] freq = new int[1001];
        for (int x : nums) {
            freq[x]++;
        }
        for (int v = 1000; v >= 0; v--) {
            if (freq[v] == 1) {
                return v;
            }
        }
        return -1;
    }
}

func largestUniqueNumber(nums []int) int {
    freq := make([]int, 1001)
    for _, x := range nums {
        freq[x]++
    }
    for v := 1000; v >= 0; v-- {
        if freq[v] == 1 {
            return v
        }
    }
    return -1
}

class Solution {
public:
    int largestUniqueNumber(vector<int>& nums) {
        vector<int> freq(1001, 0);
        for (int x : nums) {
            ++freq[x];
        }
        for (int v = 1000; v >= 0; --v) {
            if (freq[v] == 1) {
                return v;
            }
        }
        return -1;
    }
};

class Solution:
    def largestUniqueNumber(self, nums: List[int]) -> int:
        freq = [0] * 1001
        for x in nums:
            freq[x] += 1

        for v in range(1000, -1, -1):
            if freq[v] == 1:
                return v
        return -1

var largestUniqueNumber = function(nums) {
  const freq = new Array(1001).fill(0);
  for (const x of nums) {
    freq[x]++;
  }
  for (let v = 1000; v >= 0; v--) {
    if (freq[v] === 1) {
      return v;
    }
  }
  return -1;
};