LeetCode 791. 自定义字符串排序（Java语言）

题意：字符串S和 T 只包含小写字符。在S中，所有字符只会出现一次。S 已经根据某种规则进行了排序。我们要根据S中的字符顺序对T进行排序。更具体地说，如果S中x在y之前出现，那么返回的字符串中x也应出现在y之前。返回所有符合条件的字符串T。

示例:

输入:

S = "cba"

T = "abcd"

输出: "cbad"，"dcba", "cdba", "cbda"

解释: 

S中出现了字符 "a", "b", "c", 所以 "a", "b", "c" 的顺序应该是 "c", "b", "a". 

由于 "d" 没有在S中出现, 它可以放在T的任意位置. "dcba", "cdba", "cbda" 都是合法的输出。

注意:

S的最大长度为26，其中没有重复的字符。

T的最大长度为200，其中最多有1个字符未出现在S中。

S和T只包含小写字符。

最开始是老师布置的作业题，查了以后才发现是LeetCode 791. 自定义字符串排序的题。

说一下思路，就是按照给定S的顺序分别按照123编号，如果T中字符是S中没有的，则编号为0，排在最前。分别用两个字符串数组和整数数组实现，代码非常地不优雅且冗余，但还是记录对比一下。

/*
S的最大长度为26，其中没有重复的字符。
T的最大长度为200，其中最多有1个字符未出现在S中。
S和T只包含小写字符。
测试样例：
输入:
cba
abcd
输出:
cbad
dcba
cdba
cbda
 */

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;

public class Homework_1125_02 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String S, T;
        S = in.nextLine();
        T = in.nextLine();

        T_sortBy_S(S, T);

        in.close();
    }

    public static void T_sortBy_S (String S, String T) {
        int[] indexS = new int[26];
        int[] indexT = new int[200];

        //初始化
        for (int i = 0; i < indexS.length; i++) {
            indexS[i] = 0;
        }
        for (int i = 0; i < indexT.length; i++) {
            indexT[i] = 0;
        }

        //为S编号
        for (int i = 0; i < S.length(); i++) {
            indexS[i] = i+1;
        }
        
        //根据S为T对应编号
        for (int iOfT = 0; iOfT < T.length(); iOfT++) {
            for (int iOfS = 0; iOfS < S.length(); iOfS++) {
                if (T.charAt(iOfT) == S.charAt(iOfS)) {
                    indexT[iOfT] = indexS[iOfS];
                }
            }
        }
        //记录indexT[iOfT]=0的符号
        char is0Str = 'n';
        for (int i = 0; i < T.length(); i++) {
            if (indexT[i] == 0) {
                is0Str = T.charAt(i);
            }
        }
        //对indexT排序
        Arrays.sort(indexT, 0, T.length());
        //根据S输出T
        //先找出indexT中有几个非0
        int countIsNot0_OfIndexT = 0;
        for (int i = 0; i < indexT.length; i++) {
            if (indexT[i] > 0) {
                countIsNot0_OfIndexT ++;
            }
        }
        //有n个非0就有n+1种输出，StringBuffer中有直接插入字符的方法，下面有转换
        StringBuffer SB = new StringBuffer();
        for (int i = 0; i < indexT.length; i++) {
            if (indexT[i] > 0) {
                SB.append(S.charAt(indexT[i]-1));
            }
        }
        StringBuffer outputSB = new StringBuffer();
        for (int i = 0; i < countIsNot0_OfIndexT+1; i++) {
            outputSB.setLength(0);//清空outputSB
            outputSB.append(SB);
            //重新插入并输出
            outputSB.insert(i, is0Str);
            System.out.println(outputSB);
        }
    }
}

下面是大佬的实现，对照查看后，发现思路是一样的，我当时也没有想到要用Map，并且以下代码重写了Arrays.sort方法的Comparator方法，代码非常优美：

public String customSortString(String S, String T) {
        StringBuilder stringBuilder = new StringBuilder();
        Map<Character, Integer> map = new HashMap<Character, Integer>();
        for (int i = 0; i < S.length(); ++i) {
            map.put(S.charAt(i), i);
        }
        Character[] charArr = new Character[T.length()];
        for (int i = 0; i < T.length(); ++i) {
            charArr[i] = T.charAt(i);
        }
        Arrays.sort(charArr, new Comparator<Character>() {

            @Override
            public int compare(Character arg0, Character arg1) {
                // TODO Auto-generated method stub
                int value0 = map.getOrDefault(arg0, 26);
                int value1 = map.getOrDefault(arg1, 26);
                return value0 - value1;
            }
        });
        for (int i = 0; i < charArr.length; ++i) {
            stringBuilder.append(charArr[i]);
        }
        return stringBuilder.toString();
    }