15、数打印从1到最大的n位数——剑指offer——大数加法和全排列

数打印从1到最大的n位数

问题描述：输入数字n，按顺序打印出从1到最大的n位进制数，比如输入3，则打印出1、2、3一直到999.

    首先本题可以说非常有陷阱，没说N是多大，所以要考虑大数问题，或者用排列组合。

    本方法思想：

        方法1：因为没说N多大，所以考虑写一个大整数加法实现，难点在大整数加法的实现上

        方法2：用排列组合实现，难点在全排列的递归调用上（本题打印时，打印出001这样的数字，应该打印前处理一下，后续更新，先领会思想）

持续更新...

代码附下

Java实现：

方法1：大整数加法

package 打印从1到最大的n位数;
/**
 * 大整數加法
 * 
 * @author user
 *
 */
public class BigCountAddMethod {
    public static void main(String[] args) {
        int n = 0;
        print2Max(5);
    }
    private static void print2Max(int n) {
        StringBuffer sBuffer = new StringBuffer();
        for (int i = 0; i < n; i++) {
            sBuffer.append("9");
        }
        String string = sBuffer.toString();
        System.out.println(string);
        String sum = "0";
        while (!string.equals(sum)) {
            sum = BigNumberAdd(sum, "1");
            System.out.println(sum);
        }
    }
    public static String BigNumberAdd(String str1, String str2) {
        int len1 = str1.length();
        int len2 = str2.length();
        char ch1[] = str1.toCharArray();
        char ch2[] = str2.toCharArray();
        reverseString(ch1);
        reverseString(ch2);
        int result[] = new int[Math.max(len1, len2) + 1];
        int curIndex = 0;
        while (curIndex < len1 && curIndex < len2) {
            result[curIndex] = Integer.parseInt(String.valueOf(ch1[curIndex]))
                    + Integer.parseInt(String.valueOf(ch2[curIndex]));
            curIndex++;
        }
        if (curIndex < len1) {
            // 说明str1比较长
            for (int i = curIndex; i < len1; i++) {
                result[i] = Integer.parseInt(String.valueOf(ch1[i]));
            }
        }
        if (curIndex < len2) {
            // 说明str2比较长
            for (int i = curIndex; i < len2; i++) {
                result[i] = Integer.parseInt(String.valueOf(ch2[i]));
            }
        }
        // 处理进位
        for (int i = 0; i < result.length - 1; i++) {
            int carry = result[i] / 10;// 进位
            result[i] = result[i] % 10;
            result[i + 1] = result[i + 1] + carry;
        }
        StringBuffer sBuffer = new StringBuffer();
        for (int i = 0; i < result.length; i++) {
            sBuffer.append(String.valueOf(result[i]));
        }
        String finalString = sBuffer.reverse().toString();
        if (finalString.charAt(0) == '0') {
            return finalString.substring(1);
        }
        return sBuffer.reverse().toString();
    }
    private static void reverseString(char[] cha) {
        // TODO Auto-generated method stub
        for (int i = 0; i < cha.length / 2; i++) {
            char temp = cha[i];
            cha[i] = cha[cha.length - 1 - i];
            cha[cha.length - 1 - i] = temp;
        }
    }
}

方法2：全排列方法

package 打印从1到最大的n位数;
/**
 * 输入数字n，按顺序打印出从1到最大的n位进制数。
 * 比如输入3，则打印出1、2、3一直到999.
 * @author user
 *陷阱：没说N是多大，所以要考虑大数问题，或者用排列组合
 */
import java.util.Arrays;


public class Test {
    /**
     * 
     * @param n
     *            位数
     */
    public static void printToMax(int n) {
        if (n <= 0) {
            System.out.println("输入不合法");
            return;
        }
        char[] number = new char[n];
        Arrays.fill(number, '0');
        printNumber(number, n, 0);
    }
    /**
     * 
     * @param number字符数组
     * @param n
     *            位数
     * @param loc当前位置
     */
    private static void printNumber(char[] number, int n, int loc) {
        if (loc == n) {
            // System.out.println("打印完毕！");
            return;
        }
        // 没次给loc赋一个值，就去递归的给loc+1赋值
        for (int i = 0; i <= 9; i++) {
            number[loc] = (char) ('0' + i);
            if (loc == n - 1) {
                System.out.println(number);
            }
            printNumber(number, n, loc + 1);
        }
    }
    public static void main(String[] args) {
        printToMax(3);
    }
}

持续更新...欢迎赞赏！

https://blog.csdn.net/ustcer_93lk/article/details/80370102

如果有问题，欢迎大家留言，有更好的方法也期待大家告知。