Programa Java para eliminar recursivamente todos los duplicados adyacentes

Dada una string, elimine recursivamente los caracteres duplicados adyacentes de la string. La string de salida no debe tener duplicados adyacentes. Vea los siguientes ejemplos.

Ejemplos : 

Entrada : azxxzy 
Salida : ay 
Primero, “axxxzy” se reduce a “azzy”. 
La string «azzy» contiene duplicados, 
por lo que se reduce aún más a «ay».

Entrada : geeksforgeeg 
Salida : gksfor 
Primero, “geeksforgeeg” se reduce a 
“gksforgg”. La string «gksforgg» 
contiene duplicados, por lo que se 
reduce aún más a «gksfor».

Entrada : caaabbbaacdddd 
Salida : String vacía

Entrada : acaaabbbacdddd 
Salida : acac 

Se puede seguir el siguiente enfoque para eliminar duplicados en tiempo O(N) : 

• Comience desde el carácter más a la izquierda y elimine los duplicados en la esquina izquierda si hay alguno.
• El primer carácter debe ser diferente de su adyacente ahora. Recur para string de longitud n-1 (string sin primer carácter).
• Deje que la string obtenida después de reducir la substring derecha de longitud n-1 sea rem_str . Hay tres casos posibles 
  1. Si el primer carácter de rem_str coincide con el primer carácter de la string original, elimine el primer carácter de rem_str .
  2. Si la string restante se vacía y el último carácter eliminado es el mismo que el primer carácter de la string original. Devuelve una string vacía.
  3. De lo contrario, agregue el primer carácter de la string original al comienzo de rem_str .
• Devuelve rem_str .

La imagen de abajo es una ejecución en seco del enfoque anterior:

A continuación se muestra la implementación del enfoque anterior:

// Java program to remove all 
// adjacent duplicatesfrom a string
import java.io.*;
import java.util.*;
class GFG 
{  
  // Recursively removes adjacent 
  //  duplicates from str and returns 
  // new string. las_removed is a 
  // pointer to last_removed character
  static String removeUtil(String str, 
                           char last_removed)
  {    
    // If length of string is 1 or 0 
    if (str.length() == 0 || 
        str.length() == 1)
      return str;
  
    // Remove leftmost same characters 
    // and recur for remaining  
    // string 
    if (str.charAt(0) == str.charAt(1))
    {
      last_removed = str.charAt(0);
      while (str.length() > 1 && 
             str.charAt(0) == 
             str.charAt(1))
        str = str.substring(1, str.length());
      str = str.substring(1, str.length());
      return removeUtil(str, last_removed); 
    }
  
    // At this point, the first 
    // character is definiotely different  
    // from its adjacent. Ignore first 
    // character and recursively  
    // remove characters from remaining string 
    String rem_str = removeUtil(
           str.substring(1, str.length()), 
                         last_removed);
  
    // Check if the first character of 
    // the rem_string matches with  
    // the first character of the original string
    if (rem_str.length() != 0 &&  
        rem_str.charAt(0) == str.charAt(0))
    {
      last_removed = str.charAt(0);
        
      // Remove first character
      return rem_str.substring(
             1, rem_str.length()); 
    } 
  
    // If remaining string becomes 
    // empty and last removed character 
    // is same as first character of 
    // original string. This is needed 
    // for a string like "acbbcddc" 
    if (rem_str.length() == 0 && 
        last_removed == 
        str.charAt(0))
      return rem_str;
  
    // If the two first characters 
    // of str and rem_str don't match,  
    // append first character of str 
    // before the first character of 
    // rem_str
    return (str.charAt(0) + rem_str);
  }
  
  static String remove(String str)  
  {
    char last_removed = '';
    return removeUtil(str, last_removed);       
  }
  
  // Driver code
  public static void main(String args[])
  {
    String str1 = "geeksforgeeg";
    System.out.println(remove(str1));
  
    String str2 = "azxxxzy";
    System.out.println(remove(str2));
  
    String str3 = "caaabbbaac";
    System.out.println(remove(str3));
  
    String str4 = "gghhg";
    System.out.println(remove(str4));
  
    String str5 = "aaaacddddcappp";
    System.out.println(remove(str5));
  
    String str6 = "aaaaaaaaaa";
    System.out.println(remove(str6));
  
    String str7 = "qpaaaaadaaaaadprq";
    System.out.println(remove(str7));
  
    String str8 = "acaaabbbacdddd";
    System.out.println(remove(str8));
  }
}
  
// This code is contributed by rachana soma 

Producción: 

gksfor
ay
g
a
qrq
acac
a

Complejidad de tiempo: la complejidad de tiempo de la solución se puede escribir como T(n) = T(nk) + O(k) donde n es la longitud de la string de entrada y k es el número de primeros caracteres que son iguales. La solución de la recurrencia es O(n)

Gracias a Prachi Bodke por sugerir este problema y la solución inicial. 

Otro enfoque:
la idea aquí es verificar si String remStr tiene el carácter repetido que coincide con el último carácter de la string principal. Si eso sucede, debemos seguir eliminando ese carácter antes de concatenar string s y string remStr.

A continuación se muestra la implementación del enfoque anterior:

// Java Program for above approach
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG 
{
  // Recursively removes adjacent 
  // duplicates from str and
  // returns new string. las_removed 
  // is a pointer to
  // last_removed character
  private static String removeDuplicates(
          String s, char ch)
  {
    // If length of string is 1 or 0
    if (s == null || s.length() <= 1) 
    {
      return s;
    }
  
    int i = 0;
    while (i < s.length()) 
    {
      if (i + 1 < s.length()
          && s.charAt(i) == s.charAt(i + 1)) 
      {
        int j = i;
        while (j + 1 < s.length() && 
               s.charAt(j) == 
               s.charAt(j + 1))
        {
          j++;
        }
        char lastChar = i > 0 ? s.charAt(i - 1) : ch;
  
        String remStr = removeDuplicates(
               s.substring(j + 1, s.length()),
          lastChar);
  
        s = s.substring(0, i);
        int k = s.length(), l = 0;
  
        // Recursively remove all the adjacent
        // characters formed by removing the
        // adjacent characters
        while (remStr.length() > 0 && 
               s.length() > 0 && 
               remStr.charAt(0) ==
               s.charAt(s.length() - 1)) 
        {
          // Have to check whether this is the
          // repeated character that matches the
          // last char of the parent String
          while (remStr.length() > 0 && 
                 remStr.charAt(0) != ch && 
                 remStr.charAt(0) == 
                 s.charAt(s.length() - 1)) 
          {
            remStr = remStr.substring(
                     1, remStr.length());
          }
          s = s.substring(0, s.length() - 1);
        }
        s = s + remStr;
        i = j;
      }
      else 
      {
        i++;
      }
    }
    return s;
  }
  
  // Driver Code
  public static void main(String[] args)
  {
  
    String str1 = "mississipie";
    System.out.println(removeDuplicates(
                       str1, ' '));
    String str2 = "ocvvcolop";
    System.out.println(removeDuplicates(
                       str2, ' '));
  }
}
// This code is contributed by Niharika Sahai

Producción:

mpie
lop

Complejidad de tiempo: O(n) 

Consulte el artículo completo sobre Eliminación recursiva de todos los duplicados adyacentes para obtener más detalles.