剑指 Offer 17. 打印从1到最大的n位数

剑指 Offer 17. 打印从1到最大的n位数
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

示例 1:

输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]

说明：

用返回一个整数列表来代替打印
n 为正整数

JAVA

题目是leetcode上的，标记为简单，要求输出为整数数组， 意思是说不用考虑大数造成的int溢出。 比剑指offer上的简单。 一下是我做的剑指offer的：
用数组模拟， 避免大数溢出

方法一：

package leetcode;
//输入为n打印从1到n的每个数，需要考虑大数问题，即整数溢出，所以用字符串模拟数字
//书上是用字符串数组，  用java还涉及类型强制转化，反正数组每个下标值0-9.所以尝试整数数组
public class PrintToMax {
    public  static  void printNumbers(int n){
        //考虑边界值
        if(n<=0){
            return;
        }
         int res[]=new int[n];
        //数组初始化
        for(int i=0;i<n;i++){
            res[i]=0;
        }
        while(!increasement(res)){
            printNum(res);
        }

    }
    //字符串模拟+1
    //每次加1之后判断是否达到了最大n位数
    //字符串从后向前存
    public  static  boolean  increasement (int[] res){
        boolean isOverFlow=false;  //判断是否溢出
        int flag=0; //表示进位
        int len=res.length; //数组长度
        for(int i=len-1;i>=0;i--){
            int thisnum=res[i]+flag; //当前位,  涉及的转化是自动的
            if(i==len-1){
                thisnum++;  //函数功能就是实现数字加1，所以在最后一位增1
            }
            if(thisnum>=10){
                //数组存满了还有进位，就说明有溢出了，
                if(i==0){
                    isOverFlow=true;
                }
                else{
                    thisnum-=10;
                    flag=1;
                    res[i]= thisnum;
                }
            }
            else {
                res[i]=thisnum;
                break;
            }
        }
        return  isOverFlow;
    }
    //字符，从第一个非0字符开始打印
    public  static  void printNum(int [] res){
        boolean isZeroBegin=true;
        int len= res.length;
        for(int i=0;i<len;i++){
            if(isZeroBegin &&  res[i]!=0)
            {
                isZeroBegin=false;
            }
            if(!isZeroBegin){
                System.out.print(res[i]);
            }
        }
        System.out.println();

    }
}

方法二：

换个思路，把数字的每一位都从0到9遍历一遍， 就得到了所有的十进制数。
用递归。
全排列。

package leetcode;
//n位数的全排列， 并且打印。 避免大数溢出还用数组。双重循环
public class PrintToMax2 {
    public  static  void  printToMax(int n){
        //考虑边界值
        if(n<=0){
            return;
        }
        int res[]=new int[n];
        for(int i=0;i<10;i++){
            res[0]=i;
            toMaxRecursive(res,n,0);
        }
    }
    public  static  void  toMaxRecursive(int [] res,int len,int index){
        //递归停止条件
        if(index==len-1)
        {
            printNum(res);
            return;
        }
        for(int i=0;i<10;i++){
            res[index+1]=i;
            toMaxRecursive(res,len,index+1);
        }
    }
    public  static  void printNum(int [] res){
        boolean isZeroBegin=true;
        int len= res.length;
        for(int i=0;i<len;i++){
            if(isZeroBegin &&  res[i]!=0)
            {
                isZeroBegin=false;
            }
            if(!isZeroBegin){
                System.out.print(res[i]);
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        printToMax(4);
    }
}