求一个有限长度字符串 最长的有序可重复字符串长度

package acm;

/**
 * @author qxl
 */
public class SequenceCharMax {
    /**
     * 输入一可重复的整数数组，求最长升序数组长度
     *
     * 比如：
     * 输入：[1, 2, 3, 4]
     * 输出：4
     * 输入：[1, 5, 2, 3, 3, 4]
     * 输出：5
     * 输入：[1, 5, 3, 4]
     * 输出：3
     * @param args
     */
    // 或者利用堆栈实现
    public static void main(String[] args) {

        int[] randomNum = {1, 2, 3, 4, 5, 6};
       // sequenceMaxLength(randomNum);
        getMaxLength(randomNum);
    }


    /**
     * 有一种建立模型的思想，先将问题进行拆分，拆出简单的模型，实现简单的模型后，在进行组合
     * @param array
     */
    public static void sequenceMaxLength(int [] array){
        //首先实现一次循环
        for(int i=0;i<array.length;i++){

        }
        /****思路首先是实现第一次循环*****/

        //首先实现一次循环  相当于移动窗口
        int movFlag=array.length;
        //子串起始位置  i+1;
        int startIndex=1;
        //存储当前最后一位有序值
        int currentMaxVal=array[0];


        //存储组合元素集合
        String[]  combinCollection=new String[movFlag];
        // movflag 完成移动窗口的从 movflag 2到 array.length的移动  一次完成 首位元素和剩余元素的组合操作
        while ((movFlag--)>0){
            //存储拼接值记录
            StringBuffer  restAppend=new StringBuffer();
            //拼接组合的第一个元素
            restAppend.append(array[0]);
            for(int j=startIndex;j<array.length;j++ ){
              if(currentMaxVal<array[j]){
                  currentMaxVal=array[j];
                 restAppend.append(array[j]);
              }
            }
            //存储一次组合队列
            combinCollection[movFlag]=restAppend.toString();
            //循环一次startIndex 就会加1
            startIndex++;
            //重置 curentMaxVal 为组合首位元素
            currentMaxVal=array[0];


        }
        for(int i=0;i<combinCollection.length;i++){
            System.out.println(combinCollection[i]);
        }
    }

    /**
     * 获取有序最大长度值
     * @param array
     */
    public  static  void getMaxLength(int [] array){
        int maxLength=0;
        /****思路首先是实现第一次循环*****/
        for(int i=0;i<array.length;i++){
            //首先实现一次循环  相当于移动窗口
            int movFlag=array.length-i;
            //子串起始位置  i+1;
            int startIndex=i+1;
            //存储当前最后一位有序值,假设每次寻的第一位就是最后一位有序值
            int currentMaxVal=array[i];


            //存储组合元素集合
            String[]  combinCollection=new String[movFlag];
            // movflag 完成移动窗口的从 movflag 2到 array.length的移动  一次完成 首位元素和剩余元素的组合操作
            while ((movFlag--)>0){
                //存储拼接值记录
                StringBuffer  restAppend=new StringBuffer();
                //拼接组合的第一个元素
                restAppend.append(array[i]);
                for(int j=startIndex;j<array.length;j++ ){
                    if(currentMaxVal<=array[j]){
                        currentMaxVal=array[j];
                        restAppend.append(array[j]);
                    }
                }
                //存储一次组合队列
                combinCollection[movFlag]=restAppend.toString();
                //循环一次startIndex 就会加1
                startIndex++;
                //重置 curentMaxVal 为组合首位元素
                currentMaxVal=array[i];


            }
            for(int k=0;k<combinCollection.length;k++){
                System.out.println("第"+i+"次"+combinCollection[k]);
                if(maxLength<combinCollection[k].length()){
                    maxLength=combinCollection[k].length();
                }
            }
        }
        System.out.println("有序值最大的长度为"+maxLength);

    }


}