Question

我正在解决这个问题，作为学校的任务。但是当我提交代码时，我的两个测试用例出错了？我不知道出了什么问题。我检查了各种其他测试案例和角落案例，一切正确。

这是我的代码：

    public static boolean isPermutation(String input1, String input2) {

       if(input1.length() != input2.length())
       {
           return false;
       }

       int index1 =0;
       int index2 =0;
       int count=0;


       while(index2<input2.length())
       {

           while(index1<input1.length())
           {
               if( input1.charAt(index1)==input2.charAt(index2) )
               {
                   index1=0;
                   count++;
                   break;
               }
             index1++;     

           }
           index2++;
       }


       if(count==input1.length())
       {
           return true;
       }


       return false;

}

SAMPLE INPUT

abcde
baedc

输出

true

SAMPLE INPUT

abc
cbd

输出

false

Answer 1

更简单的解决方案是对两个字符串中的字符进行排序并比较这些字符数组。

String.toCharArray()返回String
Arrays.sort(char \[\])对字符数组进行排序
Arrays.equals(char \[\], char \[\])来比较数组

实施例

public static void main(String[] args) {
    System.out.println(isPermutation("hello", "olleh"));
    System.out.println(isPermutation("hell", "leh"));
    System.out.println(isPermutation("world", "wdolr"));
}

private static boolean isPermutation(String a, String b) {
    char [] aArray = a.toCharArray();
    char [] bArray = b.toCharArray();
    Arrays.sort(aArray);
    Arrays.sort(bArray);
    return Arrays.equals(aArray, bArray);
}

没有排序的更长篇大论的解决方案将检查A中的每个字符也在B

中

private static boolean isPermutation(String a, String b) {
    char[] aArray = a.toCharArray();
    char[] bArray = b.toCharArray();

    if (a.length() != b.length()) {
        return false;
    }
    int found = 0;
    for (int i = 0; i < aArray.length; i++) {
        char eachA = aArray[i];
        // check each character in A is found in B
        for (int k = 0; k < bArray.length; k++) {
            if (eachA == bArray[k]) {
                found++;
                bArray[k] = '\uFFFF'; // clear so we don't find again
                break;
            }
        }
    }
    return found == a.length();
}

Answer 2

您有两种方法可以继续

对两个字符串进行排序，然后比较两个字符串
计算字符串中的字符然后匹配。

按照教程here

Answer 3

如果String是ASCII，您可以使用下一种方法：

创建256个元素int array
在string1
在string2
如果所有元素都是0，那么string2就是string1

此方法的总体复杂性为O(n)。唯一的缺点是charCount数组的空间分配：

public static boolean isPermutation(String s1, String s2) {
    if (s1.length() != s2.length()) {
        return false;
    }
    int[] charCount = new int[256];
    for (int i = 0; i < s1.length(); i++) {
        charCount[s1.charAt(i)]++;
        charCount[s2.charAt(i)]--;
    }
    for (int i = 0; i < charCount.length; i++) {
        if (charCount[i] != 0) {
            return false;
        }
    }
    return true;
}

如果您的字符串可以包含非ASCII值，则可以使用HashMap<String, Integer>作为字符数存储来实现相同的方法

Answer 4

我有一个递归方法来解决排列问题。我认为这段代码看起来很难，但是如果你想了解它，你会看到这段代码的美妙之处。递归总是很难理解但很好用！此方法返回输入的String''的所有排列，并将它们保存在数组'arr []'中。 “t”的值最初为空白“”。

import java.io.*;
class permute_compare2str
{
    static String[] arr= new String [1200];
    static int p=0;
    void permutation(String s,String t)
    {
        if (s.length()==0)
        {
            arr[p++]=t;
            return;
        }
        for(int i=0;i<s.length();i++)
            permutation(s.substring(0,i)+s.substring(i+1),t+s.charAt(i));
    }
    public static void main(String kr[])throws IOException
    {
        int flag = 0;
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter the first String:");
        String str1 = br.readLine();
        System.out.println("Enter the second String:");
        String str2 = br.readLine();
        new permute_compare2str().permutation(str1,"");
        for(int i = 0; i < p; ++i)
        {
            if(arr[i].equals(str2))
            {
                flag = 1;
                break;
            }
        }
        if(flag == 1)
            System.out.println("True");
        else
        {
            System.out.println("False");
            return;
        }
    }
}

我可以看到的一个限制是数组的长度是固定的，因此无法返回大字符串值's'的值。请根据要求改变相同。此问题还有其他解决方案。

我已经分享了这段代码，因为您实际上可以使用它来获取直接打印的字符串的排列，而不使用数组。

下面：

void permutations(String s,String t)
    {
        if (s.length()==0)
        {
            System.out.print(t+" ");
            return;
        }
        for(int i=0;i<s.length();i++)
            permutations(s.substring(0,i)+s.substring(i+1),t+s.charAt(i));
    }

's'的值是需要排列的字符串，'t'的值再次为空“”。

Answer 5

我需要O（n log n）因为我对每个字符串进行排序，并且我使用了更多的空间来存储每个字符串

public static boolean checkPermutation(String a,String b){
    return sortString(a).equals(sortString(b));
}
private static String sortString(String test) {
    char[] tempChar = test.toCharArray();
    Arrays.sort(tempChar);
    return new String(tempChar);
}

Answer 6

const isDev = process.env.NODE_ENV !== "production";
module.exports = {
    basePath: isDev ? "": "/portfolio",
    assetPrefix: isDev ? "": "/portfolio/"
}

Answer 7

public static boolean isStringArePermutate(String s1, String s2){
    if(s1==null || s2==null) {
        return false;
    }
    
    int len1 = s1.length();
    int len2 =s2.length();
    

    if(len1!=len2){
        return false;
    }
    for(int i =0;i<len1;i++){
        if(!s1.contains(String.valueOf(s2.charAt(i)))) {
            return false;
        }
        s1=s1.replaceFirst(String.valueOf(s2.charAt(i)), "");
    }   

    if(s1.equals("")) {
        return true;
    }
    return false;
}

检查两个字符串是否相互排列？

7 个答案: