java数据结构与算法刷题-----LeetCode504. 七进制数

java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：https://blog.csdn.net/grd_java/article/details/123063846

当使用经典算法除基取余法后，发现效率最快的是调用的系统提供的API，所以我研究了底层代码，会在方法二给出。法一依然是经典的除基取余法。

1. 倒退+迭代（除基取余法）

解题思路：时间复杂度O($lo{g}_2|num|$)，空间复杂度O($lo{g}_2|num|$)

1. 如果是0，则不需要转换，直接返回0
2. 创建一个negative的boolean型变量，如果num是负数，就设置为true
3. 然后num取绝对值，我们只对正数操作
4. 我们通过字符数组，来保存除基取余的结果
5. 每次都将取余7的结果保存到数组中，然后num变为除以7的商。就是除基取余的原理。直到num被除完。
6. 最后如果negative是true，就添加一个负号
7. 因为除基取余法，需要从后往前读取结果，所以需要我们将数组反转后返回

代码

class Solution {
    public String convertToBase7(int num) {
        if (num == 0) return "0";//如果是0，则不需要转换，直接返回0
        boolean negative = num < 0;//是否是负数
        num = Math.abs(num);//保证我们操作的是正数
        StringBuffer digits = new StringBuffer();//保存答案
        while (num > 0) {//除基取余
            digits.append(num % 7);//取余
            num /= 7;//除基
        }
        if (negative) {//是负数就加负号
            digits.append('-');
        }
        return digits.reverse().toString();//反转字符串返回，因为除基取余法需要从后往前取答案
    }
}

2. 省略掉反转操作

解题思路：时间复杂度O($lo{g}_2|num|$)，空间复杂度O($lo{g}_2|num|$)

1. 法一中，我们最后需要将整个结果进行反转操作，因为这是除基取余的特性
2. 但是如果我们从一开始就反着添加结果，最后不就不需要反转了吗？

代码

class Solution {
    public String convertToBase7(int num) {
        char[] toChar = new char[33];//字符数组
        boolean negative = (num<0);//是否是负数
        int charPosition = 32;//字符数组的插入下标，从后往前插入
        if(!negative)num = -num;//如果是正数，也改为负数，我们只对负数进行操作
        while(num <= -7){//只要还<-7，就继续除基取余
            //因为num是负数，取余后还需要取负(-(num % 7))。最后需要将其转换为字符(char)('0'+(-(num % 7)))
            toChar[charPosition--] = (char)('0'+(-(num % 7)));
            num = num/7;//除基
        }
        toChar[charPosition] = (char) ('0'+(-num));//将最后剩下的>-7的余数添加
        if(negative)toChar[--charPosition] = '-';//如果是负数，额外添加一个负号
        //charPosition是目前转换后的7进制起始下标，(33 - charPosition)为转换后的数字的长度，charPosition + (33 - charPosition) 为末尾下标。
        //Arrays.copyOfRange(buf, charPosition, charPosition+(33 - charPosition))将其截取出来，然后生成字符串s
        String s = new String(Arrays.copyOfRange(toChar, charPosition, charPosition+(33 - charPosition)));
        return s;
    }
}

3. 系统提供API的自实现

解题思路：时间复杂度O($lo{g}_2|num|$)，空间复杂度O($lo{g}_2|num|$)

1. Java提供的API是通过字节数组实现，效率更高
2. 我们也通过字节数组将其实现. 而其实现居然和我们法二中大差不差，而且也是省略了反转操作。居然和我优化后的思路是一样的。

代码：效率会比法二高很多，但是官方测试用例太小，已经无法体现出差距了，如果数据量够大，一定是这个方法的字节数组更快。

class Solution {
    static final char[] digits = {
            '0' , '1' , '2' , '3' , '4' , '5' ,
            '6' , '7' , '8' , '9' , 'a' , 'b' ,
            'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
            'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
            'o' , 'p' , 'q' , 'r' , 's' , 't' ,
            'u' , 'v' , 'w' , 'x' , 'y' , 'z'
    };//对应表，我们想要用int的0得到char的'0'。而通过这个会有更好的效率，另外如果是16进制，10对应a，11对应b....
    //逢七进一
    public String convertToBase7(int num) {
        byte[] buf = new byte[33];//字节数组，速度更快
        boolean negative = (num<0);//如果是负数，就设置为true
        int charPosition = 32;//下标，从后往前
        if(!negative)num = -num;//我们只对负数操作，如果num不是负数，就改为负数
        while(num <= -7){//只要还小于等于-7，就继续除基取余
            //num%7会得到本次的余数，而它是个负数，所以我们进行-(num % 7)会得到正数，
            //然后访问digits[-(num % 7)]得到对应的char类型字符。然后通过(byte)转换为ASCII二进制码
            buf[charPosition--] = (byte)digits[-(num % 7)];//将其放到字节数组中charPosition位置
            num = num/7;//去除本次取得的余数，进行下一次除基取余
        }
        buf[charPosition] = (byte) digits[-num];//将最后剩余的无法被7整除的num放入字节数组中
        if(negative)buf[--charPosition] = '-';//如果是负数，额外放入一个负号
        //charPosition是目前转换后的7进制起始下标，(33 - charPosition)为转换后的数字的长度
        //charPosition + (33 - charPosition) 为末尾下标。
        //Arrays.copyOfRange(buf, charPosition, charPosition+(33 - charPosition))将其截取出来，然后生成字符串s
        String s = new String(Arrays.copyOfRange(buf, charPosition, charPosition+(33 - charPosition)));
        return s;//将字符串返回
    }
}