字符串反转记录总结

Posted 2020-11-19 w-gao

前文：  

           最近在一家公司面试问到这个问题，之前有看过，但印象不深，故也成为失败因素的一点吧，特此记录下来。

           学习参考博客：https://blog.csdn.net/cghu1201/article/details/78490934

代码：

         

package algorithm;

/**
 * @ProjectName: practice$
 * @Package: algorithm$
 * @ClassName: Reverse$
 * @Description:
 * @Author: WG
 * @CreateDate: 2018/6/22$ 19:19$
 * @UpdateUser: 更新者
 * @UpdateDate: 2018/6/22$ 19:19$
 * @UpdateRemark: 更新内容
 * @Version: 1.0
 */
public class Reverse {


    public static void main(String[] args) {
        String demo = "abcdefg";
        String result = reverseRecurive(demo);
        System.out.println(result);
    }

    /**
     * 首先用String的charAt方法分解字符串，然后用一个临时的字符串接收每次
     * 循环的字符串，最后通过一个小技巧，把每次分解的字符串（s.charAt(i)+reverse;）
     * 的s.charAt(i)放在上一次字符串存储的前面，就可的到后面的字符串在前面，而前面
     * 的字符串在后面
     *
     * @param s
     * @return
     */
    public static String CharAtReverse(String s) {
        int length = s.length();
        String reverse = "";
        for (int i = 0; i < length; i++) {
            reverse = s.charAt(i) + reverse;
        }
        return reverse;
    }


    /**
     * 这个方法直接把字符串转换成char型数组，然后循环最后的字符，从后往前用
     * 临时字符串存储，最后的字符串反转的效果
     *
     * @param s
     * @return
     */
    public static String reverseCharArray(String s) {
        char[] array = s.toCharArray();
        String reverse = "";
        for (int i = array.length - 1; i > 0; i--) {
            reverse += array[i];
        }
        return reverse;
    }

    /**
     * 此方法最为快捷，直接用底层生成好的StringBuilder.reverse方法生成
     *
     * @param s
     * @return
     */
    public static String reverseStringBuilder(String s) {
        StringBuilder sb = new StringBuilder(s);
        String afterreverse = sb.reverse().toString();
        return afterreverse;
    }

    /**
     * 最后递归方法也最难为理解，但也逼格最高。
     * 算法过程：1.将字符串拆分成两串，类似于半分查找，比如abcdefg，拆分成abc-defg
     *          2.将右边的字符串放在临时字符串的左边位置，这是伏笔
     *          3.将defg（reverseRecurive(right)） 继续递归,可以得到 fg-de
     *             3.1   fg 递归
     *                   gf 递归  g 单个  出口   f 单个  出口
     *                   然后演变成gf
     *             3.2   de 递归
     *                   ....
     *          4.将 abc递归（reverseRecurive(left)）
     *              ....
     *
     *          最后得出右边递归后的顺序+左边递归后的顺序
     *
     * @param s
     * @return
     */
    public static String reverseRecurive(String s) {
        int length = s.length();
        int test = length / 2;
        if (length <= 1)
            return s;
        String left = s.substring(0, length / 2);
        String right = s.substring(length / 2, length);

        String afterReverse = reverseRecurive(right) + reverseRecurive(left);

        return afterReverse;


    }


}