求数组最大最小值差小于m的最大子串长度

最近看了一道题目，主要是求出一个数组中子串的最大和最小值的差不大于m的最长子串的长度。
在编程的过程中就体会到了小函数的强大之处，因为函数短小，功能单一明确，非常有利于编程。

在一个很长的上下文思考问题，脑子理不清楚，而那种一个函数五六行，则非常便于理解前后逻辑关系。

import java.util.*;


public class Main {

    public static void main(String[] args) {
        int input[] = {10, 1, 3, 5, 9};
        int m = 4;
        System.out.println(new Main().maximumLength(input, m));
    }


    public int maximumLength(int[] input, int m) {
        Map<Integer, List<Integer>> result = getValidSubs(input, m);
        Set<Map.Entry<Integer, List<Integer>>> entries = result.entrySet();
        int len = 0;
        for (Map.Entry<Integer, List<Integer>> pair : entries) {
            System.out.println(pair.getValue());
            len = Math.max(len, pair.getValue().size());
        }
        return len;
    }

    /**
     * 返回值为
     * 0 - 从序号0开始的最长子串
     * [10]
     * 1- 从序号1开始的最长子串
     * [1, 3, 5]
     * 2- 从序号2开始的最值不大于m的最长子串
     * [3, 5]
     *
     * @param input 输入数组
     * @param m     子串最值的差不大于m
     * @return 子串中最大值和最小值差不大于m的所有子串
     */
    private Map<Integer, List<Integer>> getValidSubs(int[] input, int m) {
        Map<Integer, List<Integer>> result = new HashMap<>();

        for (int i = 0; i < input.length; i++) {
            List<Integer> subList = new ArrayList<>();
            for (int j = i; j < input.length; j++) {
                subList.add(input[j]);

                if (sub(subList) > m) {
                    subList.remove(subList.size() - 1);
                    result.put(i, subList);
                    break;
                }
                // 这个也是合法的条件，调试的时候就可以看到当右侧指针移动到最后一位仍然有效，那么该subList也是合法的。这个也比较重要
                if (j == input.length - 1) {
                    result.put(i, subList);
                }
            }
        }
        return result;
    }

    /**
     * 求List中最大值
     *
     * @param subs
     * @return
     */
    private int max(List<Integer> subs) {
        return Collections.max(subs);
    }

    /**
     * 求List中最小值
     *
     * @param subs
     * @return
     */
    private int min(List<Integer> subs) {
        return Collections.min(subs);
    }

    /**
     * @param subs 一个list中最大与最小值的差
     * @return
     */
    private int sub(List<Integer> subs) {
        return max(subs) - min(subs);
    }
}

上述代码中，getValidSubs仍然不好理解，我们可以更进一步去重构，采用体联函数的方式构造再提炼一个小函数。

下文进一步优化，采用了Queue的接口实现，LinkedList，使用removeLast，并且获取从序号i开始的最长子串单独提炼函数，语义就会更加明确，代码撰写也会更加的简单。
所以在编程时，关键不是一个多么复杂的难题，而是可以拆解成有序的步骤，这样代码就会清晰易懂
在这个过程中，短小，精悍，单一功能是我们要遵守的法则。有了这个，就有了可读性，和可理解性。

import java.util.*;


public class Main {

    public static void main(String[] args) {
        int input[] = {10, 1, 3, 5, 9};
        int m = 4;
        System.out.println(new Main().maximumLength(input, m));
    }


    public int maximumLength(int[] input, int m) {
        Map<Integer, Collection<Integer>> result = getValidSubs(input, m);
        Set<Map.Entry<Integer, Collection<Integer>>> entries = result.entrySet();
        int len = 0;
        for (Map.Entry<Integer, Collection<Integer>> pair : entries) {
            System.out.println(pair.getValue());
            len = Math.max(len, pair.getValue().size());
        }
        return len;
    }

    /**
     * 返回值为
     * 0 - 从序号0开始的最长子串
     * [10]
     * 1- 从序号1开始的最长子串
     * [1, 3, 5]
     * 2- 从序号2开始的最值不大于m的最长子串
     * [3, 5]
     *
     * @param input 输入数组
     * @param m     子串最值的差不大于m
     * @return 子串中最大值和最小值差不大于m的所有子串
     */
    private Map<Integer, Collection<Integer>> getValidSubs(int[] input, int m) {
        Map<Integer, Collection<Integer>> result = new HashMap<>();

        for (int i = 0; i < input.length; i++) {
            Collection<Integer> subList = sub(input, m, i);
            result.put(i, subList);
        }
        return result;
    }

    /**
     * 本函数的目的是为了找到从下标i对应的数字开始的有效的最长子串
     *
     * @param input 输入数组
     * @param m     子串最最大值和最小值的差不大于m
     * @param i     i代表下标索引，
     * @return
     */
    private Collection<Integer> sub(int[] input, int m, int i) {
        LinkedList<Integer> result = new LinkedList<>();
        for (int j = i; j < input.length; j++) {
            result.add(input[j]);
            if (sub(result) > m) {
                result.removeLast();
                return result;
            }

            if (j == input.length - 1) {
                return result;
            }

        }
        return result;
    }

    /**
     * 求List中最大值
     *
     * @param subs
     * @return
     */
    private int max(Collection<Integer> subs) {
        return Collections.max(subs);
    }

    /**
     * 求List中最小值
     *
     * @param subs
     * @return
     */
    private int min(Collection<Integer> subs) {
        return Collections.min(subs);
    }

    /**
     * @param subs 一个list中最大与最小值的差
     * @return
     */
    private int sub(Collection<Integer> subs) {
        return max(subs) - min(subs);
    }
}

原始题目
算法（队列）：给定数组如arr=[2,3,4,5,77,5,6,77,66,65],计算 所有子串数组中最大值减最小值的结果不大于给定参数num 的子串个数