Leetcode594. 最长和谐子序列（哈希，排序）

https://leetcode-cn.com/problems/longest-harmonious-subsequence/submissions/

和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。
现在，给定一个整数数组，你需要在所有可能的子序列中找到最长的和谐子序列的长度。
示例 1:
输入: [1,3,2,2,5,2,3,7]
输出: 5
原因: 最长的和谐数组是：[3,2,2,2,3].
说明: 输入的数组长度最大不超过20,000.

/*
思路一：
将数组排序(采用直接插入排序)，然后依次找前后差为1的，并记录首个值--超出时间限制了。。。
采用快排过了。。。

思路二：这里用一个map存储数组中每个元素出现的次数，然后遍历map的keySet（这里建议先对map的key进行排序），找出前后相差为1的key，计算出其对应的value值，返回最大的即可

*/

void insert_sort(int *nums, int numsSize){
    int i = 0;
    int j = 0;
    for(i = 1; i < numsSize; i++){
        int tmp = nums[i];
        for(j = i - 1; j >= 0; j--){
            if(tmp < nums[j]){ //从小到大排序
                nums[j + 1] = nums[j]; // 后移
            } else{
                break;
            }
        }
        nums[j + 1] = tmp; // 注意为什么是 j+1
    }
}

void quick_sort(int *arr, int start, int end){
	if (start >= end) return;

	int i = start;
	int j = end;
	while (i < j)
	{
		while (arr[j] >= arr[start] && i < j) // 从基准数的对面开始走
			j--;
		while (arr[i] <= arr[start] && i < j)
			i++;

		if (i < j){
			int tmp = arr[i];
			arr[i] = arr[j];
			arr[j] = tmp;
		}
	}
	int tmp = arr[start];
	arr[start] = arr[i];
	arr[i] = tmp;

	quick_sort(arr, start, i -1);
	quick_sort(arr, i + 1, end);
}

int findLHS(int* nums, int numsSize){
    if(numsSize < 2) return 0;
    
    //insert_sort(nums, numsSize);
    quick_sort(nums, 0, numsSize - 1);

    int i = 0;
    int j = 1;
    int max = 0;
    for(; j < numsSize;){
        int val = nums[j] - nums[i];
        if(1 == val){
            max = j - i + 1 > max ? j - i + 1 : max;
            j++;
        }
        if(0 == val){
            j++;
        }
        if(val > 1){
            i++;
            if(i == j) j++;
        }
    }
    
    return max;
}