求最大子串和 最长子串的java写法

同事去面试问到求最大和的子串，举例来说给你一个有正有负的数组， 1 -1 2 -4 5 6 -3，它的最大和就是 5 6 所组成的子串和11。根据其隔离性，即任何子串内部都不会有这样一个结构 2 -4，因为如果包含这个子串，必定不是最大子串（2-4<0）,因此可以根据此性质，将数组进行分割，而分割的标志就是小于0的结构。

public static void main(String[] args) {

        int[] array = {1,2,-4,3,5,-4,7,8,2,-1,6,-5,-200,3,47,-2};

        System.out.println(findMaxValue(array));

        //寻找最大子串
        int [] subArray = findMaxSubArray(array);
        for(int tmp : subArray){
            System.out.print(tmp+ " ");
        }

    }

    /**
     * @Description:找到最大子串和
     * @param array
     * @return
     * @returType:int
     */
    public static int findMaxValue(int[] array){
        int max = 0;
        int sum = 0;
        for(int i=0;i<array.length;i++){
            sum = sum + array[i];
            if(sum > max){
                max = sum;
　　　　
            }else if(sum<0){
                sum = 0;
            }
        }
        return max;
    }

    /**
     * @Description:找到一个字符串的最大子串
     * @param array
     * @return
     * @returType:int[]
     */
    public static int[] findMaxSubArray(int[] array){
        int max = 0;
        int sum = 0;
        int start = 0;
        int end = 0;
        int tmpStart = 0;
        for(int i=0;i<array.length;i++){
            sum = sum + array[i];
            if(sum > max){
                max = sum;
                start = tmpStart;
                end = i;
            }else if(sum<0){
                sum = 0;
                tmpStart = i;
            }
        }
        return Arrays.copyOfRange(array, start+1, end+1);//截取不包括自己
    }

还有一种是求，给定一个数组，求数组中最长的子串，子串的头和尾是同一个数字。例如：1，2，3，4，2，4  2的间距是3

public static void main(String[] args) {

        int[] array = {1,2,-4,3,5,-4,7,8,2,-1,6,-5,-200,3,47,-2};
//寻找最长子串
        int[] lenArray = findMaxLengthArray(array);
        for(int tmp : lenArray){
            System.out.print(tmp+ " ");
        }

    }

/**
     * @Description:求最长子串
     * @param array
     * @return
     * @returType:int[]
     */
    public static int[] findMaxLengthArray(int[] array){
        //key 放置数组的元素，value 第一个元素存放起始位置，第二个放置结束位置，第三个元素存放距离
        Map<Integer, Integer[]> map = new HashMap<Integer, Integer[]>();
        for(int i=0;i<array.length;i++){
            if(map.get(array[i])==null){
                Integer[] ints = new Integer[3];
                ints[0]=i;//初始位置
                ints[1]=i;//结束位置
                ints[2]=0;//初始长度
                map.put(array[i], ints);
            }else{
                map.get(array[i])[1]=i;
                map.get(array[i])[2]=i-map.get(array[i])[0];
            }
        }
        Iterator<Entry<Integer, Integer[]>> iterator = map.entrySet().iterator();
        int max = 0;
        int start = 0;
        int end = 0;
        int key = 0;
        while(iterator.hasNext()){
            Entry<Integer, Integer[]> entry = iterator.next();
            if(entry.getValue()[2]>max){
                max = entry.getValue()[2];
                start = entry.getValue()[0];
                end = entry.getValue()[1];
                key = entry.getKey();
            }
        }
        System.out.println("最大长度的数字是："+ key);
        System.out.println("最大长度为:"+max);
        return Arrays.copyOfRange(array, start+1, end+1);//截取不包括自己
    }

实际上使用了一个hashmap，value存储了开始位置，结束位置以及长度，因此一遍遍历数组，再一遍遍历hashmap就可以求出最长距离，Integer[] 改成hashmap效率会更高一些，时间复杂度为O(n)，空间复杂度高一些