<p>Given an integer array <code>nums</code>, return <em>the maximum difference between two successive elements in its sorted form</em>. If the array contains less than two elements, return <code>0</code>.</p>

<p>You must write an algorithm that runs in linear time and uses linear extra space.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [3,6,9,1]
<strong>Output:</strong> 3
<strong>Explanation:</strong> The sorted form of the array is [1,3,6,9], either (3,6) or (6,9) has the maximum difference 3.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [10]
<strong>Output:</strong> 0
<strong>Explanation:</strong> The array contains less than 2 elements, therefore return 0.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>0 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
</ul>

class Solution {
public:
    int maximumGap(vector<int>& nums) {
        const int size = nums.size();
        const auto [minimum, maximum] = std::minmax_element(nums.begin(), nums.end());
        if (*minimum == *maximum) {
            return 0;
        }
        const int bucketSize  = std::max(1, static_cast<int>(std::ceil((*maximum - *minimum) / (size - 1))));
        const int bucketCount = ((*maximum - *minimum) / bucketSize) + 1;
        std::vector<int> minimumBuckets(bucketCount, std::numeric_limits<int>::max());
        std::vector<int> maximumBuckets(bucketCount, std::numeric_limits<int>::min());

        for (const auto& ele : nums) {
            const int bucketIndex = (ele - *minimum) / bucketSize;
            minimumBuckets[bucketIndex] = std::min(minimumBuckets[bucketIndex], ele);
            maximumBuckets[bucketIndex] = std::max(maximumBuckets[bucketIndex], ele); 
        }

        int maximumGapValue = bucketSize;
        int previous = maximumBuckets[0];
        for (int i = 1; i < bucketCount; ++i) {
            if (minimumBuckets[i] == std::numeric_limits<int>::max()) {
                continue;
            }

            maximumGapValue = std::max(maximumGapValue, minimumBuckets[i] - previous);
            previous = maximumBuckets[i];
        }

        return maximumGapValue;
    }
};
92551