leetcode 164:Maximum Gap

题意:

给定非排序数组,找出其排序后相邻元素的最大差值。

线性时间空间、元素数少于2时返回0、元素值非负且int范围内。

思路:

排序最快nlogn不符合要求;

参考网上,学习了桶排序的方法;

桶排序:按值分段处理;

设定桶大小和桶个数;

因为ans>=(MAX-MIN)/(len-1);

桶大小:(MAX-MIN)/(len-1)向上取整,(注意为0时取1)

桶个数:(MAX-MIN)/桶大小+1;

ans取值只可能是桶A的最小值-桶B的最大值形式;不会在桶内取;(因为桶内最大差值小于桶大小)

 1 class Solution {
 2 public:
 3     int maximumGap(vector<int>& nums) {
 4         int len = nums.size();
 5         if(len<2)
 6             return 0;
 7         int minv = nums[0];
 8         int maxv = nums[0];
 9         for(int i=1;i<len;i++)
10         {
11             if(nums[i]<minv)
12                 minv = nums[i];
13             if(nums[i]>maxv)
14                 maxv = nums[i];
15         }
16         if(maxv==minv)
17             return 0;
18         int x = (maxv-minv)/(len-1);
19         if(x!=(maxv-minv)*1.0/(len-1)||x==0) //小数4.1
20         {
21             x++;
22         }
23         int n = (maxv-minv)/x+1;
24         vector<int> bmin(n,INT_MAX);
25         vector<int> bmax(n,INT_MIN);
26
27
28         for(int i=0;i<len;i++)
29         {
30             int p = (nums[i]-minv)/x;
31             bmin[p] = min(bmin[p],nums[i]);
32             bmax[p] = max(bmax[p],nums[i]);
33         }
34         int ans = -1;
35         int last = -1;
36         for(int i=0;i<n;i++)
37         {
38             if(bmin[i]==INT_MAX)
39                 continue;
40             if(last == -1)
41             {
42                 last = bmax[i];
43                 continue;
44             }
45             ans = max(ans, bmin[i]-last );
46             last = bmax[i];
47         }
48         return ans;
49     }
50 };

时间: 2024-11-11 03:13:35

leetcode 164:Maximum Gap的相关文章

LeetCode 164. Maximum Gap (排序)

题目 题意:就是给你一个数组,让你输出排好序后,相邻元素差值最大的那个差值. 题解:首先,当然我们可以用快排,排完序之后,遍历一遍数组,就能得到答案了.但是快速排序的效率是O(n* logn),不是题目要求的线性效率,也就是O(n)的效率. 那么诸多排序算法中,也是由线性效率的排序算法,当然这些算法的目标是线性效率,而在实际情况中的效率也并不是最快的.首先就是基数排序,基数排序的效率是O(n*k), k 是由元素的位数决定的. 线性时间的排序还有一个桶排序,桶排序,一开始选择一些桶,每个桶代表一

164. Maximum Gap

/* * 164. Maximum Gap * 2016-6-4 by Mingyang * 这个题目首先要求的是linear的时间,所以我个人的预测就是bucketsort * bucketsort就是把一个list分成几个bucket再分别把每一个桶排序,再合起来 * 比如我现在有10个如果selection sort就是100的时间复杂度,那么需要分成两个5 * 就是两个25相加,就是50 * 假设有N个元素A到B. * 那么最大差值不会小于ceiling[(B - A) / (N - 1

No.164 Maximum Gap

No.164 Maximum Gap Given an unsorted array, find the maximum difference between the successive elements in its sorted form. Try to solve it in linear time/space. Return 0 if the array contains less than 2 elements. You may assume all elements in the

LeetCode – Refresh – Maximum Gap

Sorting solution O(nlogn): 1 class Solution { 2 public: 3 int maximumGap(vector<int> &num) { 4 int len = num.size(), result = 0; 5 if (len < 2) return 0; 6 sort(num.begin(), num.end()); 7 for (int i = 0; i < len-1; i++){ 8 result = max(res

leetcode 155: Maximum Gap

Maximum Gap Total Accepted: 2946 Total Submissions: 12695 Given an unsorted array, find the maximum difference between the successive elements in its sorted form. Try to solve it in linear time/space. Return 0 if the array contains less than 2 elemen

LeetCode:164. Maximum Gap

这道题比较简单,虽然不知道为什么被贴上了困难的标签~ 贴上题目: Given an unsorted array, find the maximum difference between the successive elements in its sorted form. Return 0 if the array contains less than 2 elements. 中文翻译: 现在有一个无序数组,找出数组在排序后,相邻元素差值的最大值 如果元素个数少于两个,就返回0. emmmmm

LeetCode[Sort]: Maximum Gap

Given an unsorted array, find the maximum difference between the successive elements in its sorted form. Try to solve it in linear time/space. Return 0 if the array contains less than 2 elements. You may assume all elements in the array are non-negat

[leedcode 164] Maximum Gap

Given an unsorted array, find the maximum difference between the successive elements in its sorted form. Try to solve it in linear time/space. Return 0 if the array contains less than 2 elements. You may assume all elements in the array are non-negat

【leetcode】Maximum Gap(hard)★

Given an unsorted array, find the maximum difference between the successive elements in its sorted form. Try to solve it in linear time/space. Return 0 if the array contains less than 2 elements. You may assume all elements in the array are non-negat