Java 在不使用额外缓冲区的情况下删除重复项

我编写了一个简单的程序来删除字符串中的重复项，而不使用任何额外的缓冲区。有人能告诉我这是否是一个好的解决方案吗？我只是想知道是否有比下面的解决方案更好的解决方案

编辑： 如果我传入'Follow Up'作为输入，我应该返回唯一的字符串'FW Up'

    public static void removeDuplicateString(String input) {
        String value1 = input;
        String value2 = input;
        String finalValue = "";
        int count = 0;
        char char1;
        char char2;
        for (int i = 0; i < value1.length(); i++) {
            char1 = value1.charAt(i);
            for (int j = 0; j < value2.length(); j++) {
                char2 = value2.charAt(j);
                if (char1 == char2) {
                    count++;
                }
            }
            if (count > 1) {
                //System.out.println(i);
            } else {
                finalValue = finalValue + char1;
            }

            count = 0;
        }
        System.out.println(finalValue);
    }

}

publicstaticvoidremoveduplicatestring（字符串输入）{
字符串值1=输入；
字符串值2=输入；
字符串finalValue=“”；
整数计数=0；
char-char1；
char-char2；
对于（int i=0；i1）{
//系统输出打印LN（i）；
}否则{
最终价值=最终价值+字符1；
}
计数=0；
}
System.out.println（最终值）；
}
}

您可以尝试以下方法：

public String removeDuplicateChars(String inputString) {
        if (inputString.length() <= 1 ) {
            return inputString;
        }
        if(inputString.substring(1, 2).equals(inputString.substring(0, 1)) ) {
            return removeDuplicateChars(inputString.substring(1));
        } else {
            return inputString.substring(0, 1) + removeDuplicateChars(inputString.substring(1));
        }
    }

   public static void removeDuplicateString(String input) {
        char[] ch = input.toCharArray();
        char[] copy = new char[ch.length];
        char[] avoid = new char[ch.length];
        int counter = 0,count=0;
        for (int i = 0 ; i < ch.length; i++)
        {
            char cch = ch[i];
            boolean duplicate = false;
            if (input.indexOf(cch)==i && input.indexOf(cch,i+1)==-1)
            {
                for (int j = 0 ; j <=count ; j++)
                {
                    if (avoid[i]==cch)
                    {
                        duplicate = true;
                        break;
                    }
                }
                if (!duplicate)
                {
                    copy[counter] = cch;
                    counter++;
                }
            }
            else
            {
                avoid[count] = cch;
                count++;
            }
        }
        String finalString = new String(copy,0,counter);
        System.out.println(finalString);
    }

public String removeDuplicateChars（String-inputString）{
如果（inputString.length（）public），您可以尝试以下方法：

public String removeDuplicateChars(String inputString) {
        if (inputString.length() <= 1 ) {
            return inputString;
        }
        if(inputString.substring(1, 2).equals(inputString.substring(0, 1)) ) {
            return removeDuplicateChars(inputString.substring(1));
        } else {
            return inputString.substring(0, 1) + removeDuplicateChars(inputString.substring(1));
        }
    }

   public static void removeDuplicateString(String input) {
        char[] ch = input.toCharArray();
        char[] copy = new char[ch.length];
        char[] avoid = new char[ch.length];
        int counter = 0,count=0;
        for (int i = 0 ; i < ch.length; i++)
        {
            char cch = ch[i];
            boolean duplicate = false;
            if (input.indexOf(cch)==i && input.indexOf(cch,i+1)==-1)
            {
                for (int j = 0 ; j <=count ; j++)
                {
                    if (avoid[i]==cch)
                    {
                        duplicate = true;
                        break;
                    }
                }
                if (!duplicate)
                {
                    copy[counter] = cch;
                    counter++;
                }
            }
            else
            {
                avoid[count] = cch;
                count++;
            }
        }
        String finalString = new String(copy,0,counter);
        System.out.println(finalString);
    }

publicstaticvoidremoveduplicatestring（字符串输入）{
char[]ch=input.toCharArray（）；
char[]copy=新字符[ch.length]；
char[]避免=新字符[ch.length]；
int计数器=0，计数=0；
for（int i=0；i
另一个解决方案：

public static void removeDuplicateString2(String input) {
    wh:
    while(true)
    {
        for(char c : input.toCharArray())
        {
            if(input.contains("" + c + c))
            {
                input = input.replaceAll("["+ c +"]" + "["+ c +"]", "");
                continue wh;
            }
        }
        break;
    }

    System.out.println(input);
}

丑陋但有效。
像这样使用基于正向前瞻的正则表达式从给定字符串中删除重复字符怎么样：

String nonDup = input.replaceAll("(.)(?=.*?\\1)", "");

现场演示：您可以使用“合并排序”或“快速排序”（假设您可以在排序数据时使用临时数组来分配数据，则需要额外的“O（n）”空间）

一旦对数组进行了排序，就可以简单地遍历数组，将一个元素与下面的元素进行比较，每次发现给定的元素等于相同的元素时，就将元素向后移动一个位置

通过这样做，您可以：


O（N LOG N）因为排序
O（N）遍历所有元素
O（M）向后移动元件

根据重复的数量，此代码可能会变得非常慢，因为向后移动元素以擦除重复项的成本很高。
您能给我们提供测试用例吗？使用的参数是什么，预期的返回plz是什么？如果它想保留第一次出现的字符并取出另一次出现的同一个字符，怎么做？我不明白，你能用一个例子说明一下吗？好的，它是有效的。如果我输入“适当”，结果是“适当”。但是，如果我希望每个字符只出现一次，结果是“适当”，如何使用regex
opriate
每个字符也只有一次，但位置不同。如果您想要不同的行为，请随时发布新问题。