输入：多次测试，第一行为数组元素个数，第二行为数组元素。
输出：数组排序后相邻元素的最大差值。
该题关键看思路3.
思路1，先将数组排序，然后设置一个全局变量为最大值，相减之后作比较。
思路2，先将数组排序，然后设置一个vector，将相邻元素差值存入大根堆，最后输出堆首即可
思路3，利用桶排序的思想，可以实现算法时间复杂度为O(N)
如果在算法时间复杂度没有要求的话直接使用思路1即可，不需要将差值存起来。
思路1，简单的冒泡排序，然后比较即可
#include<iostream>
using namespace std;
void swap(int arr[],int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
void buble_sort(int arr[], int arr_len) {
for (int e = arr_len-1; e>0; e--) {
for (int i = 0; i < e; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr,i, i + 1);
}
}
}
}
int get_max(int a, int b) {
return a > b ? a : b;
}
int main() {
int n;
while (cin >> n) {
int* p = new int[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
buble_sort(p, n);
int max_gap = 0;
for (int i = 0; i < n-1; i++) {
max_gap = get_max(max_gap,(p[i + 1] - p[i]));
}
cout << max_gap << endl;;
}
return 0;
}思路2：主要是想练习一下大根堆的创建，如果没有必要只要求输出的话不需要存放起来再输出。建立大根堆之后直接输出堆首即可
扫描二维码关注公众号，回复：
5648612 查看本文章
//堆排序
#include<iostream>
using namespace std;
void swap(int arr[],int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
void buble_sort(int arr[], int arr_len) {
for (int e = arr_len-1; e>0; e--) {
for (int i = 0; i < e; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr,i, i + 1);
}
}
}
}
int get_max(int a, int b) {
return a > b ? a : b;
}
//建立大根堆的过程
void heap_insert(int arr[], int index) {
while (arr[index] > arr[(index - 1) / 2]) {
swap(arr, index, (index - 1) / 2);
index = (index - 1) / 2;
}
}
int main() {
int n;
while (cin >> n) {
int* p = new int[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
buble_sort(p, n);
int* ptr = new int[n - 1];
for (int i = 0; i < n-1; i++) {
ptr[i] = p[i + 1] - p[i];
heap_insert(ptr, i);
}
cout << ptr[0] << endl;
}
return 0;
}思路3:为n个数创建n+1个桶，然后每个桶用三个数组表示：该桶是否进来过数，该桶的最大值，该桶的最小值
创建n+1个桶这样肯定存在一个空桶，目的是排除最大的差值来自于同一个桶，那么排序后的数组元素相邻差的最大值肯定发生在每一个非空桶的最小值与其前一个桶的最大值之差。
//堆排序
#include<iostream>
using namespace std;
int get_min(int a, int b) {
return a < b ? a : b;
}
int get_max(int a, int b) {
return a > b ? a : b;
}
//对数组求最小值
int find_min(int arr[],int arr_len) {
int min = arr[0];
for (int i = 0; i < arr_len; i++) {
min = get_min(min, arr[i]);
}
return min;
}
//对数组求最大值
int find_max(int arr[], int arr_len) {
int max = arr[0];
for (int i = 0; i < arr_len; i++) {
max = get_max(max, arr[i]);
}
return max;
}
//交换函数
void swap(int arr[], int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//获取num放在那个桶
int bucket(long num, long len, long min, long max) {
return (int)((num - min)*len) / (max - min);
}
//返回最大的序号
int maxGap(int arr[],int arr_len) {
if (arr == NULL || arr_len < 2) {
return 0;
}
int min = find_min(arr, arr_len);
int max = find_max(arr, arr_len);
if (min == max) {
return 0;
}
//建立三个数组，分别存放该桶是否进来过数，该桶的最大值，该桶的最小值
bool* hasNum = new bool[arr_len + 1];
for (int i = 0; i < arr_len + 1; i++) {
hasNum[i] = 0;//全部初始化为0
}
int* maxs = new int[arr_len + 1];
int* mins = new int[arr_len + 1];
int bid = 0;//bucket ID
for (int i = 0; i < arr_len; i++) {
bid = bucket(arr[i], arr_len, min, max);//确定这个数应该放入哪个桶
//如果该桶本来没有元素，则将min和max设置为第一个进来的元素，否则比较将min、max和新进来的元素作比较
//最后只保留该桶中最大值和最小值
mins[bid] = hasNum[bid] ? get_min(mins[bid], arr[i]) : arr[i];//同时更新该桶中的mins和maxs值
maxs[bid] = hasNum[bid] ? get_max(maxs[bid], arr[i]) : arr[i];
hasNum[bid] = 1;//确定了当前桶号要来信号了就要将当前的桶信息改为1
}
int res = 0;
int lastMax = maxs[0];
int i = 1;
for (; i <= arr_len; i++) {
if (hasNum[i]) {
res = get_max(res, mins[i] - lastMax);
lastMax = maxs[i];
}
}
return res;
}
int main() {
int n;
while (cin >> n) {
int* p = new int[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
int res = maxGap(p, n);
cout << res << endl;
}
return 0;
} 