Java 递归地从字符串中删除重复字符
我需要帮助来确定如何从字符串中删除重复字符。它必须递归进行，这才是真正的问题Java 递归地从字符串中删除重复字符,java,Java,我需要帮助来确定如何从字符串中删除重复字符。它必须递归进行，这才是真正的问题 public class FEQ2 { /** * @param args */ public static void removeDups(String s, int firstChar, int secondChar) { if (s.length() == 1) { System.out.println(s);
public class FEQ2 {
/**
* @param args
*/
public static void removeDups(String s, int firstChar, int secondChar) {
if (s.length() == 1) {
System.out.println(s);
}
char a = s.charAt(firstChar);
if (a == s.charAt(secondChar)) {
s = a + s.substring(secondChar + 1);
}
System.out.println(s);
removeDups(s, firstChar + 1, secondChar + 1);
//return s;
}
public static void main(String[] args) {
//System.out.println(removeDups("AAAABBARRRCC", 1));
removeDups("AAAABBARRRCC", 0 , 1);
}
}
您可以这样做：
public static String removeDups(String s)
{
if ( s.length() <= 1 ) return s;
if( s.substring(1,2).equals(s.substring(0,1)) ) return removeDups(s.substring(1));
else return s.substring(0,1) + removeDups(s.substring(1));
}
INPUT: "AAAABBARRRCC"
OUTPUT: "ABARC"
publicstaticstringremovedups（字符串s）
{
if（s.length（）递归执行操作的一般技巧是将所有变量转换为参数，并将所有赋值转换为函数调用。对于更复杂的内容，您可能需要多个函数，但通常可以很容易地将每个循环转换为函数：
function(){
int i=0; int x=0; //initialize
while(condition){
x = x+i; //update
i = i+1;
}
return x;
}
变成
function(i,x){ //variables are now parameters
if(condition){
return x;
}else{
return function(i+1, x+i); //update
}
}
main(){
function(0,0); //initialize
===============
下面是一些重复的删除代码，举个例子（它的功能与您的不同）
变成
remove_duplicates(str, i, out_str, chars_used):
if i < 0:
return out_str
else:
c = str[i]
if c in chars_used:
return remove_duplicates(str, i-1, out_str, chars_used)
else:
return remove_duplicates(str, i-1, out_str+c, chars_used+[c])
删除重复项（str、i、out、chars）：
如果i<0：
返回
其他：
c=str[i]
如果使用字符中的c：
返回删除重复项（str、i-1、out_str、已使用字符）
其他：
返回删除重复项（str、i-1、out\u str+c、chars\u used+[c]）
这对您有帮助吗
public static String getUniqueChars(String realString) {
StringBuilder resultString = null;
try {
List<Character> characterArray = new <Character> ArrayList();
for(char c : realString.toCharArray()) {
characterArray.add(c);
}
resultString = new StringBuilder();
for(Character c : new TreeSet<Character>(characterArray)) {
resultString.append(c.charValue());
}
} catch (Exception e) {
e.printStackTrace();
}
resultString.toString();
}
公共静态字符串getUniqueChars（字符串realString）{
StringBuilder resultString=null；
试一试{
List characterArray=新建ArrayList（）；
for（char c:realString.toCharArray（））{
characterArray.add（c）；
}
resultString=new StringBuilder（）；
对于（字符c：新树集（字符数组））{
resultString.append（c.charValue（））；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
resultString.toString（）；
}
专用静态字符串删除程序（字符串s）{
int n=s.长度（）；
int i=0；
int j=1；
Map mark=newhashmap（）；
而（j我认为这更简单：
private static String removeDups(String input){
if (input.length() <= 1) return input;
if (input.charAt(0) == input.charAt(1))
return removeDups(input.substring(1));
else
return input.charAt(0)+removeDups(input.substring(1));
}
private static String removeDups（字符串输入）{
如果在C中输入（input.length（）：
/*@params:
*src—要从中删除DUP的输入字符串指针.string。
*dest—输出字符串指针。作为空字符串传入。
*iter——从重复删除开始的索引。（0）
* ---------------------------------------------------------
*目的：
*递归地从字符串中删除重复字符。
*/
void remove_Dups_递归（char*src、char*dest、int iter）{
/*基本情况1-->空或1个字母字符串*/
如果（strlen（src）到达字符串末尾*/
如果（国际热核实验堆==strlen（src））{
返回；
}
/*以前遇到过当前的“iter”元素*/
if（strchr（dest，src[iter]）==NULL）{
dest[strlen（dest）]=src[iter]；
iter++；
递归删除重复（src、dest、iter）；
}
/*以前从未遇到过当前的“iter”元素*/
否则{
iter++；
递归删除重复（src、dest、iter）；
}
}
/*示例：aaabccaba
*产出：ABC*/
这是家庭作业中的问题吗？如果是，你能复制准确的问题吗？你能说预期的结果是什么吗？ABARC还是ABRC？如果是家庭作业-有限制，使用什么，没有什么？为家庭作业问题提供解决方案是否明智？他们会学到什么？不适用于->“azxxzy”，它应该给出->“ay”@BigShow，解决方案并不“完全”删除重复项，它们会保留每个字符，但会删除重复项。因此，字符串azxxzy的输出是azxy。您的第二种和第三种方法会对某些字符串产生不同的结果，例如：input-abcabdfcfreb output-erfabdfc | | f在重复我在这里做错了什么？请纠正我。
remove_duplicates(str, i, out_str, chars_used):
if i < 0:
return out_str
else:
c = str[i]
if c in chars_used:
return remove_duplicates(str, i-1, out_str, chars_used)
else:
return remove_duplicates(str, i-1, out_str+c, chars_used+[c])
public static String getUniqueChars(String realString) {
StringBuilder resultString = null;
try {
List<Character> characterArray = new <Character> ArrayList();
for(char c : realString.toCharArray()) {
characterArray.add(c);
}
resultString = new StringBuilder();
for(Character c : new TreeSet<Character>(characterArray)) {
resultString.append(c.charValue());
}
} catch (Exception e) {
e.printStackTrace();
}
resultString.toString();
}
private static String removeChars(String s) {
int n= s.length();
int i= 0;
int j= 1;
Map<Integer, Boolean> mark= new HashMap<>();
while(j<n) {
if(s.charAt(i)== s.charAt(j)) {
mark.put(i, true);
mark.put(j, true);
if(i== 0) {
i= j+1;
j= i+1;
} else {
i= i-1;
j= j+1;
}
} else {
i= j;
j= j+1;
}
}
String str= "";
for(int k= 0;k<n;k++) {
if(!mark.containsKey(k)) {
str+= s.charAt(k);
}
}
return str;
}
private static String removeDups(String input){
if (input.length() <= 1) return input;
if (input.charAt(0) == input.charAt(1))
return removeDups(input.substring(1));
else
return input.charAt(0)+removeDups(input.substring(1));
}
/* @params:
* src -- input string pointer. String to remove dups from.
* dest -- output string pointer. Passed in as empty string.
* iter -- index from where duplicate removal starts. (0)
* ---------------------------------------------------------
* Purpose:
* Removes duplicate characters from a string recursively.
*/
void remove_Dups_recursively(char *src, char *dest, int iter){
/* base case 1 --> empty or 1 letter string */
if(strlen(src) <= 1){
dest = src;
return;
}
/* base case 2 --> reached end of string */
if(iter == strlen(src)){
return;
}
/* current 'iter' element has been encountered before */
if(strchr(dest, src[iter]) == NULL){
dest[strlen(dest)] = src[iter];
iter++;
remove_Dups_recursively(src, dest, iter);
}
/* current 'iter' element has not been encountered before */
else{
iter++;
remove_Dups_recursively(src, dest, iter);
}
}
/* EXAMPLE: AAABBABCCABA
* OUTPUT: ABC */