绝对差不超过限制的最长连续子数组

绝对差不超过限制的最长连续子数组
* 给你一个整数数组 nums ，和一个表示限制的整数 limit，请你返回最长连续子数组的长度，该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。
如果不存在满足条件的子数组，则返回 0 。
示例 1：
输入：nums = [8,2,4,7], limit = 4
输出：2
解释：所有子数组如下：
[8] 最大绝对差 |8-8| = 0 <= 4.
[8,2] 最大绝对差 |8-2| = 6 > 4.
[8,2,4] 最大绝对差 |8-2| = 6 > 4.
[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.
[2] 最大绝对差 |2-2| = 0 <= 4.
[2,4] 最大绝对差 |2-4| = 2 <= 4.
[2,4,7] 最大绝对差 |2-7| = 5 > 4.
[4] 最大绝对差 |4-4| = 0 <= 4.
[4,7] 最大绝对差 |4-7| = 3 <= 4.
[7] 最大绝对差 |7-7| = 0 <= 4.
因此，满足题意的最长子数组的长度为 2 。
示例 2：
输入：nums = [10,1,2,4,7,2], limit = 5
输出：4
解释：满足题意的最长子数组是 [2,4,7,2]，其最大绝对差 |2-7| = 5 <= 5 。
示例 3：
输入：nums = [4,2,2,2,4,4,2,2], limit = 0
输出：3
提示：
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
0 <= limit <= 10^9

特别low的思想，就是利用String求代码：

个人认为：子串利用String求解不管任何类型简单易操作

子序列问题使用双层循环解决问题，或者递归也可，只要把握这两两点问题大概能解出来，不过就是有点low

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class code_26_LongestContinuousSubarrayWithAbsoluteDiffLessThanOrEqualTolimit {
    public static void main(String[] args) {
//        String string = "123";
//        char[] jude_array = string.toCharArray();
//        for (int i = 0; i < jude_array.length; i++) {
//            System.out.println(jude_array[i]);
//        }
        
    }
    public static int longestSubarray(int[] nums, int limit) {
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < nums.length; i++) {
             str.append(nums[i]);
        }
        String value = str.toString();
        List<String> list = getAllSubstrings(value);
        List<Integer> list2 = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            boolean flag = get_jude(list.get(i),limit);
            if (flag) {
                list2.add(list.get(i).length());
            }
        }
        Collections.sort(list2);
        
        
        return list2.get(list2.size() - 1);
    }
    
     public static List<String> getAllSubstrings(String s){
            List<String> arrayList = new ArrayList<String>();
            for (int i = 0; i < s.length() ; i++) {
                for (int j = i+1; j < s.length()+1 ; j++) {
                    arrayList.add(s.substring(i, j));
                }
            }
            return arrayList;
        }
    
    /*
     * 判断array里面最小值于最大值的差是不是小于一个数
     * 
     */
    public static Boolean get_jude(String str , int limit){
        char[] jude_array = str.toCharArray();
        List<Character> characters = new ArrayList<>();
        for (int i = 0; i < jude_array.length; i++) {
            characters.add(jude_array[i]);
        }
        Collections.sort(characters);
        if(Math.abs(Integer.parseInt(characters.get(0) + "") - Integer.parseInt(characters.get(characters.size() -1)+"")) <= limit){
            return true;
        }
        return false;
    }
}

或者利用简单的滑动窗口解决，其实可以这样理解但凡涉及到数组求两个值之间的关系，就可以使用滑动窗口，而滑动窗口的模板又是固定的

大概就是这样的：

left ，right = 0

while（right <= array.size){

　　进行主逻辑，也就是建立left与right之间的关系即可

　　最后对right进行向右移动一定距离的操作

}

这里我使用python解决如上问题：

class Solution:
　　
　　def longestSubarray(nums, limit):

        from sortedcontainers import SortedList
        s = SortedList()
        left, right = 0, 0
        res = 0
        while right < len(nums):
            s.add(nums[right])  # 不断的向排好序的sort里面田间数据
            while s[-1] - s[0] > limit:  # 最大值与最小值之间的差距是不是大于limlt，如果大于就移除掉curr里面最左边的元素
                s.remove(nums[left])
                left += 1  # 左边向右边移动一个单元
            res = max(res, right - left + 1)  # 当在curr里面del掉最左边的元素的时候就会和最大长度的进行比较，并更新最大值的数据
            right += 1  # 右边的指针加一
        return res