【LeetCode每日一题】——164.最大间距

一【题目类别】

• 排序

二【题目难度】

• 困难

三【题目编号】

• 164.最大间距

四【题目描述】

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

五【题目示例】

• 示例 1:
  输入: [3,6,9,1]
  输出: 3
  解释: 排序后的数组是 [1,3,6,9], 其中相邻元素 (3,6) 和 (6,9) 之间都存在最大差值 3。
• 示例 2:
  输入: [10]
  输出: 0
  解释: 数组元素个数小于 2，因此返回 0。

六【题目说明】

• 你可以假设数组中所有元素都是非负整数，且数值在 32 位有符号整数范围内。
• 请尝试在线性时间复杂度和空间复杂度的条件下解决此问题。

七【解题思路】

• 这道题其实并不难，主要是注意题中的要求，线性时间复杂度，那么首先考虑堆排序和基数排序，我是用基数排序，对数组先从小到大排序，然后在这个有序数组中从头开始遍历找最大的间距，最大间距也就是当前这个元素于后一个元素的差值

八【时间频度】

• 时间复杂度：线性时间复杂度$O(N\ast K)$

九【代码实现】

1. Java语言版

package Sort;

public class p164_MaximumGap {

    public static void main(String[] args) {
        int[] nums = new int[]{3, 6, 9, 1};
        int res = maximumGap(nums);
        System.out.println("res = " + res);
    }

    public static int maximumGap(int[] nums) {
        // 如果数组元素个数小于2，返回0
        if (nums.length < 2) {
            return 0;
        }
        // 使用基数排序对数组进行排序
        int[] sortNums = radixSort(nums);
        // 找出差值最大的
        int max = 0;
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i + 1] - nums[i] > max) {
                max = nums[i + 1] - nums[i];
            }
        }
        // 返回结果
        return max;
    }

    /**
     * 因为要求线性时间复杂度，所以使用基数排序对数组进行排序（不做注释，具体请参见Java Project/DataStructures/Sort/RadixSort.java）
     *
     * @param nums 待排序数组
     * @return
     */
    public static int[] radixSort(int[] nums) {
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
        }
        int maxLength = (max + "").length();
        int[][] bucket = new int[10][nums.length];
        int[] bucketElementCounts = new int[10];
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            for (int j = 0; j < nums.length; j++) {
                int digitOfElement = nums[j] / n % 10;
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = nums[j];
                bucketElementCounts[digitOfElement]++;
            }
            int index = 0;
            for (int k = 0; k < bucketElementCounts.length; k++) {
                if (bucketElementCounts[k] != 0) {
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        nums[index++] = bucket[k][l];
                    }
                }
                bucketElementCounts[k] = 0;
            }
        }
        return nums;
    }

}

2. C语言版

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<io.h>

#define RADIX 10
#define KEYNUM 10

/*找到num的从低到高的第pos位的数据*/
int GetNumInPos(int num, int pos)
{
	int temp = 1;
	for (int i = 0; i < pos - 1; i++)
	{
		temp *= 10;
	}
	return (num / temp) % 10;
}

/*基数排序，不做注释，具体参考C_Code/BigTalkDataStructure/Sort/RadixSort.c*/
void RadixSort(int* nums, int numsLen)
{
	int *radixArr[RADIX];
	for (int i = 0; i < 10; i++)
	{
		radixArr[i] = (int *)malloc(sizeof(int) * (numsLen + 1));
		radixArr[i][0] = 0;
	}
	for (int pos = 1; pos <= KEYNUM; pos++)
	{
		for (int i = 0; i < numsLen; i++)
		{
			int num = GetNumInPos(nums[i], pos);
			int index = ++radixArr[num][0];
			radixArr[num][index] = nums[i];
		}
		for (int i = 0, j = 0; i < RADIX; i++)
		{
			for (int k = 1; k <= radixArr[i][0]; k++)
			{
				nums[j++] = radixArr[i][k];
			}
			radixArr[i][0] = 0;
		}
	}
}

int maximumGap(int* nums, int numsSize)
{
	/*如果数组长度小于2，返回0*/
	if (numsSize < 2)
	{
		return 0;
	}
	/*使用基数排序对数组排序*/
	RadixSort(nums, numsSize);
	/*找到最大间距*/
	int max = 0;
	for (int i = 1; i < numsSize; i++)
	{
		if (nums[i] - nums[i - 1] > max)
		{
			max = nums[i] - nums[i - 1];
		}
	}
	return max;
}

/*主函数省略*/

十【提交结果】

1. Java语言版
   

2. C语言版