Java 从第二个字符串中删除第一个字符串中存在的字符
我已经编写了一个程序来删除第一个字符串中存在的第二个字符串中的字符。其复杂性是BigO（n^2）。能否进一步降低复杂性Java 从第二个字符串中删除第一个字符串中存在的字符,java,algorithm,Java,Algorithm,我已经编写了一个程序来删除第一个字符串中存在的第二个字符串中的字符。其复杂性是BigO（n^2）。能否进一步降低复杂性 public class Tmp { public static void main(String[] args) { String s = "halloween"; String s1 = "halcyon"; char[] ss = s.toCharArray(); char[] ss1 = s1.t
public class Tmp {
public static void main(String[] args) {
String s = "halloween";
String s1 = "halcyon";
char[] ss = s.toCharArray();
char[] ss1 = s1.toCharArray();
for(int i=0;i<ss.length;i++){
for(int j=0;j<ss1.length;j++){
if(ss1[j] == ss[i]){
ss1[j] = 'x'; //Replace the common char with x
}
}
}
System.out.println(Arrays.toString(ss1));
}
}
您可以选择将第二个字符串转换为哈希集（如果第二个字符串中没有重复的字母）。然后检查hashmap中第一个字符串中的每个字母是否存在，若找到，则删除
O（N）遍历字符串数组的复杂性和HashSet中put/get的复杂性几乎为O（1）。您可以选择将第二个字符串转换为HashSet（如果第二个字符串中没有重复的字母）。然后检查hashmap中第一个字符串中的每个字母是否存在，若找到，则删除
O（N）遍历字符串数组的复杂度和HashSet中put/get的复杂度几乎为O（1）。如果源字符串中的所有字符都是小写字母，则可以使用大小为26的布尔数组。 然后从头到尾扫描源字符串，如果存在字符，则更新布尔数组。 然后扫描目标字符串，并使用布尔数组检查其是否存在于源数组中
复杂性将等于两个字符串长度之和。如果源字符串中的所有字符都是小写字母，则可以使用大小为26的布尔数组。 然后从头到尾扫描源字符串，如果存在字符，则更新布尔数组。 然后扫描目标字符串，并使用布尔数组检查其是否存在于源数组中 复杂性将等于两个字符串长度之和
这里您有额外的空间复杂性来存储地图 从输入字符串中删除掩码字符串中存在的字符
public class RemoveCharacterFromFisrtStringWhichPInSecondString {
public static void removeCharactersFromFirstString(String str1,String str2){
StringBuilder sb = new StringBuilder(str1.toLowerCase());
char maskArray[] = populateMaskArray(str2);
for(int i=0;i<str1.length();i++){
char ch = str1.toLowerCase().charAt(i);
int index = sb.toString().indexOf(ch);
if(maskArray[ch] == ch) {
sb.deleteCharAt(index);
}
}
System.out.println(sb.toString());
}
/**
* Time Complexity: O(m) Where m is the length of mask string.
*/
static char[] populateMaskArray(String mask) {
char[] array = new char[256];
for(int i = 0; i < mask.length(); i++) {
array[mask.charAt(i)] = mask.charAt(i);
}
return array;
}
public static void main(String[] args) {
String str1 = "India is country";
String str2 = "in";
removeCharactersFromFirstString(str1,str2);
}
}
public类从FirstStringwhichpinSecondString中删除Character{
公共静态void removeCharactersFromFirstString（字符串str1、字符串str2）{
StringBuilder sb=新的StringBuilder（str1.toLowerCase（））；
char maskArray[]=populateMaskArray（str2）；
对于（int i=0；i从输入字符串中删除掩码字符串中存在的字符
public class RemoveCharacterFromFisrtStringWhichPInSecondString {
public static void removeCharactersFromFirstString(String str1,String str2){
StringBuilder sb = new StringBuilder(str1.toLowerCase());
char maskArray[] = populateMaskArray(str2);
for(int i=0;i<str1.length();i++){
char ch = str1.toLowerCase().charAt(i);
int index = sb.toString().indexOf(ch);
if(maskArray[ch] == ch) {
sb.deleteCharAt(index);
}
}
System.out.println(sb.toString());
}
/**
* Time Complexity: O(m) Where m is the length of mask string.
*/
static char[] populateMaskArray(String mask) {
char[] array = new char[256];
for(int i = 0; i < mask.length(); i++) {
array[mask.charAt(i)] = mask.charAt(i);
}
return array;
}
public static void main(String[] args) {
String str1 = "India is country";
String str2 = "in";
removeCharactersFromFirstString(str1,str2);
}
}
public类从FirstStringwhichpinSecondString中删除Character{
公共静态void removeCharactersFromFirstString（字符串str1、字符串str2）{
StringBuilder sb=新的StringBuilder（str1.toLowerCase（））；
char maskArray[]=populateMaskArray（str2）；
对于（inti=0；i公共类测试{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
字符串str，sbstr；
System.out.println（“输入第一个字符串：”）；
str=sc.nextLine（）；
System.out.println（“输入第二个字符串：”）；
sbstr=sc.nextLine（）；
char[]c1str=str.toCharArray（）；
char[]c2sbstr=sbstr.toCharArray（）；
对于（int j=0；j公共类测试{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
字符串str，sbstr；
System.out.println（“输入第一个字符串：”）；
str=sc.nextLine（）；
System.out.println（“输入第二个字符串：”）；
sbstr=sc.nextLine（）；
char[]c1str=str.toCharArray（）；
char[]c2sbstr=sbstr.toCharArray（）；
对于（int j=0；jpublic static String removeCharAt（String s，int pos）{
返回s.substring（0，pos）+s.substring（pos+1）；
}
公共静态void main（字符串[]args）{
String s1=“印度是伟大的”；
s1=s1.toLowerCase（）；
字符串s2=“in”；
对于（int i=0；i
公共静态字符串removeCharAt（字符串s，int-pos）{
返回s.substring（0，pos）+s.substring（pos+1）；
}
公共静态void main（字符串[]args）{
String s1=“印度是伟大的”；
s1=s1.toLowerCase（）；
字符串s2=“in”；
对于（int i=0；i
您可以将代码放在代码检查中以获得更好的结果。是的，您可以将其减少为O（n log n）
。将string1的所有字符添加到一个集合中（O（n）
）。接下来，对于string-2中的每个字符，在set-1上使用contains（）
，如果该字符存在（O（n）
）您可以将代码放在代码检查中以获得更好的结果。是的，您可以将其减少到O（n log n）
。将string1的所有字符添加到一个集合（O（n）
）。接下来，对于string-2中的每个字符，在set-1上使用contains（）
，如果该字符存在（O（n）
），则将其设置为“x”）最好是将第一个字符串转换为映射，然后从映射中找到的第二个字符串中删除字母。这种方式支持重复字符。最好是将第一个字符串转换为映射，然后从映射中找到的第二个字符串中删除字母。这种方式支持重复字符。“如果存在字符”的复杂性为O（n）。现在总复杂度将为O（n^2）“‘如果字符存在’的复杂度为O（n）。现在到
public class Test{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str,sbstr;
System.out.println("Enter the first String : ");
str = sc.nextLine();
System.out.println("Enter the second String : ");
sbstr = sc.nextLine();
char [] c1str = str.toCharArray();
char [] c2sbstr = sbstr.toCharArray();
for(int j=0;j<c2sbstr.length;j++) {
for(int i=0;i<c1str.length;i++) {
if(c1str[i] == c2sbstr[j]) {
c1str[i] = 0;
}
}
}
System.out.println("After removing the characters of second string from first string :");
for(int i=0;i<c1str.length;i++) {
System.out.print(c1str[i]);
}
}
}
public static String removeCharAt(String s, int pos) {
return s.substring(0, pos) + s.substring(pos + 1);
}
public static void main(String[] args) {
String s1 = "India is great ";
s1 = s1.toLowerCase();
String s2="in";
for (int i = 0; i < s1.length(); i++) {
for (int j = 0; j < s2.length(); j++) {
if(s2.charAt(j) == s1.charAt(i)) {
s1 = removeCharAt(s1, i);
}
}
}
System.out.println(s1);
}