164. 最大间距

1. 164. 最大间距

2. 题目叙述

给定一个无序的数组 nums，返回数组在排序之后，相邻元素之间最大的差值。如果数组元素个数小于 2，则返回 0。

你必须编写一个在「线性时间」内运行并使用「线性额外空间」的算法。

3. 模式识别

本题要求在线性时间和线性空间内完成，可使用桶排序的思想。因为排序算法如快速排序、归并排序等的时间复杂度为 $O(nlogn)$，不满足要求，而桶排序在特定条件下可以达到线性复杂度。

4. 考点分析

• 桶排序的原理和实现，需要理解如何将元素分配到不同的桶中，并根据桶之间的关系来计算最大间距。
• 对时间复杂度和空间复杂度的分析，确保算法满足线性时间和线性空间的要求。

5. 所有解法

• 桶排序：将数组元素分配到不同的桶中，每个桶记录该桶内元素的最大值和最小值，通过比较不同桶之间的间距来得到最大间距。
• 暴力排序：先对数组进行排序，然后遍历数组计算相邻元素的差值，找出最大差值。但这种方法的时间复杂度为 $O(nlogn)$，不满足题目要求。

6. 最优解法（桶排序）的C语言代码

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

// 桶结构体，用于存储每个桶的最小值和最大值
typedef struct {
    int min;  // 桶内元素的最小值
    int max;  // 桶内元素的最大值
    int is_empty;  // 标记桶是否为空
} Bucket;

// 函数用于计算最大间距
int maximumGap(int* nums, int numsSize) {
    // 如果数组元素个数小于 2，直接返回 0
    if (numsSize < 2) {
        return 0;
    }

    // 找出数组中的最小值和最大值
    int min_num = INT_MAX;
    int max_num = INT_MIN;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < min_num) {
            min_num = nums[i];
        }
        if (nums[i] > max_num) {
            max_num = nums[i];
        }
    }

    // 如果最小值和最大值相等，说明数组中所有元素都相同，最大间距为 0
    if (min_num == max_num) {
        return 0;
    }

    // 计算桶的大小
    int bucket_size = (max_num - min_num) / (numsSize - 1);
    if (bucket_size == 0) {
        bucket_size = 1;
    }
    // 计算桶的数量
    int bucket_num = (max_num - min_num) / bucket_size + 1;

    // 初始化桶数组
    Bucket* buckets = (Bucket*)malloc(bucket_num * sizeof(Bucket));
    for (int i = 0; i < bucket_num; i++) {
        buckets[i].min = INT_MAX;
        buckets[i].max = INT_MIN;
        buckets[i].is_empty = 1;
    }

    // 将元素分配到桶中
    for (int i = 0; i < numsSize; i++) {
        int bucket_index = (nums[i] - min_num) / bucket_size;
        buckets[bucket_index].is_empty = 0;
        if (nums[i] < buckets[bucket_index].min) {
            buckets[bucket_index].min = nums[i];
        }
        if (nums[i] > buckets[bucket_index].max) {
            buckets[bucket_index].max = nums[i];
        }
    }

    // 计算最大间距
    int max_gap = 0;
    int prev_max = min_num;
    for (int i = 0; i < bucket_num; i++) {
        if (!buckets[i].is_empty) {
            int gap = buckets[i].min - prev_max;
            if (gap > max_gap) {
                max_gap = gap;
            }
            prev_max = buckets[i].max;
        }
    }

    // 释放桶数组的内存
    free(buckets);

    return max_gap;
}

7. 复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组的长度。主要步骤包括遍历数组找出最小值和最大值、将元素分配到桶中以及计算最大间距，每个步骤的时间复杂度都是 $O(n)$。
• 空间复杂度：$O(n)$，主要用于存储桶数组，桶的数量最多为 $n$ 个。