1.整数反转思路及解决方案

1.理解题意

    逆序输出

    首尾交换

2.数据结构及算法思维选择

    1.逆序输出

        1.整数转字符串，字符串转数组

        2.数据结构：字符数组

        3.算法思维：遍历

    2.首尾交换

        1.整数转字符串，字符串转数组

        2.数据结构：字符数组

        3.算法思维：遍历

3.基本解法及编码实现

    1.暴力解法

        1.整数转字符串，再转字符数组

        2.反向遍历字符数组，并将元素存储到新数组

        3.将新数组转换成字符串，再转成整数输出

    2.暴力解法边界和细节问题

        1.数组索引越界

        2.数值溢出边界：溢出则返回0

        3.首位不为0

        4.符号处理

    3.暴力解法编码实现

class Solution {

    public int reverse(int x) {

        if (x == Integer.MAX_VALUE || x == Integer.MIN_VALUE) {

            return 0;

        }

        int sign = x > 0 ? 1 : -1;

        x = x < 0 ? -x : x;

        //1.将整数转为字符串,并将字符串转为数组

        String str = String.valueOf(x);

        char[] charArray = str.toCharArray();

        //2.循环遍历字符串数组,将数组元素放入新数组

        int length = charArray.length;

        char[] array = new char[length];

        for (int i = 0; i < array.length; i++) {

            array[i] = charArray[length - 1 - i];

        }

        //3.将新数组转为字符串，将字符串转为数字

        long value = Long.valueOf(String.valueOf(array));

        boolean flag = value > Integer.MAX_VALUE || value < Integer.MIN_VALUE;

        int result = flag ? 0 : (int) value;

        return result * sign;

    }

}

    4.首尾交换(优化解法)

        1.整数转字符串，再转字符数组

        2.交换首位和末位数字

        3.循环操作,依次交换,直到数组剩下1个或0个元素

        4.将原数组转换成字符串，再转成整数输出

    5.优化解法边界和细节问题

        1.数组索引越界：数组长度为偶数，反转完成标志为start>end,数组长度为奇数，反转完成标志为start==end

        2.数值溢出边界：溢出则返回0

        3.首位不为0

        4.符号处理

    6.优化解法编码实现

class Solution {

    public int reverse(int x) {

        if (x == Integer.MAX_VALUE || x == Integer.MIN_VALUE) {

            return 0;

        }

        int sign = x > 0 ? 1 : -1;

        x = x < 0 ? -x : x;

        //1.将整数转为字符串,并将字符串转为数组

        String str = String.valueOf(x);

        char[] charArray = str.toCharArray();

        //2.循环交换首位和末位数字

        //3.循环操作,依次交换,直到数组剩下1个或0个元素

        int start = 0, end = charArray.length - 1;

        while (start < end) {

            char temp = charArray[start];

            charArray[start] = charArray[end];

            charArray[end] = temp;

            start++;

            end--;

        }

        //3.将新数组转为字符串，将字符串转为数字

        //long value = Long.valueOf(String.valueOf(array));

        long value = Long.valueOf(String.valueOf(charArray));

        boolean flag = value > Integer.MAX_VALUE || value < Integer.MIN_VALUE;

        int result = flag ? 0 : (int) value;

        return result * sign;

    }

}

4.思考更优解

    1.剔除无效代码或优化空间消耗

        1.操作时必须的么

        2.数据结构是必须的么

    2.寻找更好的算法思维

        1.既然是整数，能否用数学思维

        2.借鉴其他算法

5.最优解思路及编码实现

    1.数学思维解法

        1.尝试拿个位数字

            对10取模运算得到个位数字

        2.让每一位数字变成个位数字

            先除以10，再对10取模得到十位数字

            循环上述操作

        3.将每一位数字计算累加

            将上次累加结果*10 + 新数字

    2.边界问题及细节问题

        1.从低位到高位处理，最高位结束

            最高位/10==0

            最高位%10==最高位

        2.数值溢出边界：溢出则返回0

            用long类型存放，溢出int则返回0

            新整数补充最后一位前判断溢出

        3.首位不为0

        4.符号处理

    3.最优解编码实现

class Solution {

    public int reverse(int x) {

        if (x == Integer.MAX_VALUE || x == Integer.MIN_VALUE) {

            return 0;

        }

        int sign = x > 0 ? 1 : -1;

        x = x < 0 ? -x : x;

        //1.对10取模运算得到个位数字

        //2.让每一位数字变成个位数字,先除以10，再对10取模得到十位数字

        int result = 0;

        int last = 0;

        while ((last = x % 10) != x) {

            result = result * 10 + last;

            x /= 10;

        }

        if (last != 0) {

            long re = result;

            re = re * 10 + last;

            if (re > Integer.MAX_VALUE || re < Integer.MIN_VALUE)

                result = 0;

            else

                result = (int) re;

        }

        return result * sign;

    }

}

6.总结

    1.算法思维

        遍历

        逆序

        原地交换

        数学思维:取模、累加

    2.数据结构：数组

        1.数组容量固定不变，需要在创建时指定

        2.使用连续的物理空间存储叔叔

        3.可以通过下标在O(1)的时间复杂度下读取数据

以上部分内容节选自拉钩教育-算法特训营