字符串的排序_牛客网（递归和非递归）

题目描述

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

输入描述:

输入一个字符串，长度不超过9（可能有字符重复），字符只包括大小写字母。

---

接下来我们分别用递归和非递归方法实现：

• 基于回溯思想的递归算法：

步骤：1. 找出所有可能出现在字符串第一个位置的字符所得的字符串

2. 对于步骤1中可能出现的每个字符串：固定第一个字符，求剩余字符的排列；求剩余字符的排列时跟原问题一样

---

如何求剩余字符的排列：将剩余字符的第一个字符依次和后面的字符进行交换

递归出口：求剩余字符的排列时只剩下一个字符

---

以 abc为例，图解过程如下：

---

    public static ArrayList<String> Permutation(String str) {
        ArrayList<String> list = new ArrayList<>();
        if (str != null && str.length() != 0) {
            PermutationHelper(str.toCharArray(), 0, list);
            Collections.sort(list);//对所得的list集合进行排序
        }
        return list;
    }

    private static void PermutationHelper(char[] chars, int i, ArrayList<String> list) {
        if (i == chars.length - 1) {//递归出口：遍历到数组最后一个字符了
            String val = String.valueOf(chars);//将字符数组变成字符串
            if (!list.contains(val)) {//如果list集合中不包含这个字符串，则添加（避免重复）
                list.add(val);
            }
        } else {
            for (int j = i; j < chars.length; j++) {
                swap(chars, i, j);//交换数组第i个字符和第j个字符
                PermutationHelper(chars, i + 1, list);
                swap(chars, i, j);//再次交换数组第i个字符和第j个字符，保证回到此次for循环前字符数组的状态，不影响字符数组进行下一次for循环
            }
        }
    }

    private static void swap(char[] chars, int i, int j) {
        char tmp = chars[i];
        chars[i] = chars[j];
        chars[j] = tmp;
    }
    /*
     * 基于回溯思想的递归算法：
     *     1. 找出所有可能出现在字符串第一个位置的字符所得的字符串
     *     2. 对于步骤1中可能出现的每个字符串：固定第一个字符，求剩余字符的排列；求剩余字符的排列时跟原问题一样
     *
     * 如何求剩余字符的排列：将剩余字符的第一个字符依次和后面的字符进行交换
     * 递归出口：求剩余字符的排列时只剩下一个字符
     *
     * 以 a|b|c 为例，此时list为空，由于字符串不为空且长度不为0，进入到PermutationHelper()函数中
     *
     * 此时 i=0
     * j从0开始到2：
     *
     *    j等于0 时：
     *       交换chars[0]和chars[0]后数组变成 a|b|c
     *       进入到PermutationHelper(chars,1,list)函数中：
     *           此时 i=1
     *           j从1开始到2：
     *              j等于1 时：
     *                 交换chars[1]和chars[1]后数组变成 a|b|c
     *                 进入到PermutationHelper(chars,2,list)函数中：
     *                     此时 i=2
     *                     由于此时i=2=数组长度-1，且list中不包含字符串abc，故将“abc”存入list中并返回，此时list={"abc"}
     *                 交换chars[1]和chars[1]后数组变成 a|b|c
     *              j等于2 时：
     *                 交换chars[1]和chars[2]后数组变成 a|c|b
     *                 进入到PermutationHelper(chars,2,list)函数中：
     *                    此时 i=2
     *                    由于此时i=2=数组长度-1，且list中不包含字符串cba，故将“acb”存入list中并返回，此时list={"abc","acb"}
     *                 交换chars[1]和chars[2]后数组变成 a|b|c
     *       交换chars[0]和char[0]后数组变成 a|b|c
     *
     *    j等于1 时：
     *        交换chars[0]和chars[1]后数组变成 b|a|c
     *        进入到PermutationHelper(chars,1,list)函数中：
     *            此时 i=1
     *            j从1开始到2：
     *               j等于1 时：
     *                  交换chars[1]和char[1]后数组变成 b|a|c
     *                  进入到PermutationHelper(chars,2,list)函数中：
     *                    此时 i=2
     *                    由于此时i=2=数组长度-1，且list中不包含字符串bac，故将“bac”存入list中并返回，此时list={"abc","acb","bac"}
     *                 交换chars[1]和chars[1]后数组变成 b|a|c
     *              j等于2 时：
     *                 交换chars[1]和chars[2]后数组变成 b|c|a
     *                 进入到PermutationHelper(chars,2,list)函数中：
     *                     此时 i=2
     *                     由于此时i=2=数组长度-1，且list中不包含字符串bca，故将“bca”存入list中并返回，此时list={"abc","acb","bac","bca"}
     *                 交换chars[1]和chars[2]后数组变成 b|a|c
     *       交换chars[0]和chars[1]后数组变成 a|b|c
     *
     *   j等于2 时：
     *       交换chars[0]和chars[2]后数组变成 c|b|a
     *       进入到PermutationHelper(chars,1,list)函数中：
     *            此时 i=1
     *            j从1开始到2：
     *               j等于1 时：
     *                  交换chars[1]和char[1]后数组变成 c|b|a
     *                  进入到PermutationHelper(chars,2,list)函数中：
     *                     此时 i=2
     *                     由于此时i=2=数组长度-1，且list中不包含字符串cba，故将“cba”存入list中并返回，此时list={"abc","acb","bac","bca","cba"}
     *                  交换chars[1]和chars[1]后数组变成 c|b|a
     *              j等于2 时：
     *                 交换chars[1]和chars[2]后数组变成 c|a|b
     *                 进入到PermutationHelper(chars,2,list)函数中：
     *                    此时 i=2
     *                    由于此时i=2=数组长度-1，且list中不包含字符串cab，故将“cab”存入list中并返回，此时list={"abc","acb","bac","bca","cba","cab"}
     *                 交换chars[1]和chars[2]后数组变成 c|b|a
     *       交换chars[0]和chars[2]后数组变成 a|b|c
     *
     *   到此,for循环结束，此时list={"abc","acb","bac","bca","cba","cab"}，PermutationHelper()函数调用结束
     *   利用Collections.sort()函数对list集合进行升序排序后得list={"abc","acb","bac","bca","cab","cba"}
     *
     *
     *
     * */

•  非递归算法：字典序排列算法

首先说说什么是字典序：按照字典中出现的先后顺序进行排序。

比如：

单个字符：'a' < 'b' < 'c' < ... <'z'

多个字符："abc" < "acb" < "bac" < "bca" < "cab" < "cba" 【对于字符串来说，比较大小的方式是：从左到右进行比较，如果第一个字符相等就比较第二个字符，直到能找到一位可以比较出大小的字符，则不再进行比较。而每两个字符间的比较就跟单个字符一样比较】 

其次说说什么是全排列：给定多个字符，将这些字符按照任意顺序进行排列【不能重复】，所得的所有排列称为全排列。对于n个不同的字符来说，全排列有 n! 个。

比如：

给定字符串abcd：全排列为 "abcd"、"abdc"、"acbd"、"acdb"、"adbc"、"adcb"、

                                             "bacd"、"badc"、"bcad"、"bcda"、"bdac"、"bdca"、

                                             "cabd"、"cadb"、"cbad"、"cbda"、"cdab"、"cdba"、

                                             "dabc"、"dacb"、"dbac"、"dbca"、"dcab"、"dcba"

最后说说什么是字典序排列：由于每一种排列对应一个字符串，将所有排列所对应的所有字符串按字典顺序进行排序，就叫做基于字典序的排列。

比如：

给定字符串abcd：全排列为 "abcd"、"abdc"、"acbd"、"acdb"、"adbc"、"adcb"、

                                             "bacd"、"badc"、"bcad"、"bcda"、"bdac"、"bdca"、

                                             "cabd"、"cadb"、"cbad"、"cbda"、"cdab"、"cdba"、

                                             "dabc"、"dacb"、"dbac"、"dbca"、"dcab"、"dcba"

---

字典序算法通常用来解决这样一个问题：给定某字符串的一种排列，求基于字典序的下一个排列。

那么什么叫基于字典序的下一个排列呢？

表示所求的下一个排列既要比原排列大，又不能有第三个排列位于它俩之间，也就是说下一个排列为大于原排列的最小排列。

---

例：求568721的下一个排列：

第一步：从右往左遍历原排列，遇到第一个左邻小于右邻的字符时停下，记录右邻位置 。

以568721为例，从右往左遍历时，第一个左邻小于右邻的字符为6，记录右邻8的位置为2【下标从0开始】，则左邻6的位置为1。

第二步：再次从右往左遍历原排列，第一次遇到大于第一步所求左邻字符时停下，记录此时的字符位置 。

以568721为例，从右往左遍历时，第一个大于第一步所求左邻字符的字符为7，记录7的位置为3。

第三步：交换第一步所求左邻字符和第二步所求的字符，然后倒序左邻字符后边的字符。

以568721为例，交换6和7，得578621。然后将7后面的字符倒序，得571268。

private static ArrayList<String> Permutation(String str) {
        ArrayList<String> list = new ArrayList<>();
        if (str == null || str.length() == 0) {
            return list;
        }
        char[] chars = str.toCharArray();
        Arrays.sort(chars);//将字符数组按升序排列
        list.add(String.valueOf(chars));//先将按升序排列后的字符串存入list中
        while (true) {
            int i = chars.length - 1;
            int j = chars.length - 1;
            while (i >= 1 && chars[i - 1] >= chars[i]) {//从字符数组最后一个字符开始往前遍历，寻找第一次chars[i-1]<chars[i]的位置
                i--;
            }
            if (i == 0) {//此时的数组已经是降序排列了（从右往左都是增的），表明全排列完成
                break;
            }
            while (j >= 0 && chars[j] <= chars[i - 1]) {//j从从最后一个位置开始，往前遍历，遇到大于chars[i-1]的值时停下，注意在遇到等于chars[i-1]的值的时候一定不要停下，不然会造成死循环（因为此时交换的是值相同的两个数）
                j--;
            }
            swap(chars, i - 1, j);//交换chars[i-1]和chars[j]的值
            reverse(chars, i);//反转包括chars[i]元素在内到数组结尾的所有元素
            list.add(String.valueOf(chars));
        }
        return list;
    }
    /*
     * 非递归算法：字典序排列算法
     *
     * 以 c|a|b为例，此时list为空
     * 在进入最外层while循环前，先将字符数组升序排列后变成 a|b|c，并将此时的字符数组变成字符串后存入list中：list={"abc"}
     *
     * 进入最外层while循环后的第一次循环：
     *     此时 i 经过内层第一个while循环后的值为2，j 经过内层第二个while循环后的值为2
     *     交换chars[2-1]和chars[2]后数组变成 a|c|b
     *     反转数组从下标2开始往后的元素后数组变成 a|c|b
     *     将此时的数组变成字符串后存入list中：list={"abc","acb"}
     *
     * 进入最外层while循环后的第二次循环：
     *     此时 i 经过内层第一个while循环后的值为1，j 经过内层第二个while循环后的值为2
     *     交换chars[1-1]和chars[2]后数组变成 b|c|a
     *     反转数组从下标1开始往后的元素后数组变成 b|a|c
     *     将此时的数组变成字符串后存入list中：list={"abc","acb","bac"}
     *
     * 进入最外层while循环后的第三次循环：
     *     此时 i 经过内层第一个while循环后的值为2，j 经过内层第二个while循环后的值为2
     *     交换chars[2-1]和chars[2]后数组变成 b|c|a
     *     反转数组从下标2开始往后的元素后数组变成 b|c|a
     *     将此时的数组变成字符串后存入list中：list={"abc","acb","bac","bca"}
     *
     * 进入最外层while循环后的第四次循环：
     *     此时 i 经过内层第一个while循环后的值为1，j 经过内层第二个while循环后的值为1
     *     交换chars[1-1]和chars[1]后数组变成 c|b|a
     *     反转数组从下标1开始往后的元素后数组变成 c|a|b
     *     将此时的数组变成字符串后存入list中：list={"abc","acb","bac","bca","cab"}
     *
     * 进入最外层while循环后的第五次循环：
     *     此时 i 经过内层第一个while循环后的值为2，j经过内层第二个while循环后的值为2
     *     交换chars[2-1]和chars[2]后数组变成 c|b|a
     *     反转数组从下标2开始往后的元素后数组变成 c|b|a
     *     将此时的数组变成字符串后存入list中：list={"abc","acb","bac","bca","cab","cba"}
     *
     * 进入最外层while循环后的第六次循环：
     *     此时right经过内层第一个while循环后的值为0，跳出最外层while循环，并返回此时的list集合：list={"abc","acb","bac","bca","cab","cba"}
     * */