Open In App
Related Articles

Java Program To Recursively Remove All Adjacent Duplicates

Improve Article
Save Article
Like Article

Given a string, recursively remove adjacent duplicate characters from the string. The output string should not have any adjacent duplicates. See the following examples.


Input: azxxzy 
Output: ay 
First “azxxzy” is reduced to “azzy”. 
The string “azzy” contains duplicates, 
so it is further reduced to “ay”.

Input: geeksforgeeg 
Output: gksfor 
First “geeksforgeeg” is reduced to 
“gksforgg”. The string “gksforgg” 
contains duplicates, so it is further 
reduced to “gksfor”.

Input: caaabbbaacdddd 
Output: Empty String

Input: acaaabbbacdddd 
Output: acac 

The following approach can be followed to remove duplicates in O(N) time: 

  • Start from the leftmost character and remove duplicates at left corner if there are any.
  • The first character must be different from its adjacent now. Recur for string of length n-1 (string without first character).
  • Let the string obtained after reducing right substring of length n-1 be rem_str. There are three possible cases 
    1. If first character of rem_str matches with the first character of original string, remove the first character from rem_str.
    2. If remaining string becomes empty and last removed character is same as first character of original string. Return empty string.
    3. Else, append the first character of the original string at the beginning of rem_str.
  • Return rem_str.

Below image is a dry run of the above approach:

Below is the implementation of the above approach:


// Java program to remove all 
// adjacent duplicatesfrom a string
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 = 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()), 
    // 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 == 
      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";
    String str2 = "azxxxzy";
    String str3 = "caaabbbaac";
    String str4 = "gghhg";
    String str5 = "aaaacddddcappp";
    String str6 = "aaaaaaaaaa";
    String str7 = "qpaaaaadaaaaadprq";
    String str8 = "acaaabbbacdddd";
// This code is contributed by rachana soma 



Time Complexity: The time complexity of the solution can be written as T(n) = T(n-k) + O(k) where n is length of the input string and k is the number of first characters which are same. Solution of the recurrence is O(n).

Space complexity: O(n) for recursion stack, where n is the length of the string.

Thanks to Prachi Bodke for suggesting this problem and initial solution. 

Another Approach:
The idea here is to check whether the String remStr has the repeated character that matches the last char of the parent String. If that is happening then we have to keep removing that character before concatenating string s and string remStr.

Below is the implementation of the above approach:


// Java Program for above approach
import java.util.*;
import java.lang.*;
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))
        char lastChar = i > 0 ? s.charAt(i - 1) : ch;
        String remStr = removeDuplicates(
               s.substring(j + 1, s.length()),
        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;
    return s;
  // Driver Code
  public static void main(String[] args)
    String str1 = "mississipie";
                       str1, ' '));
    String str2 = "ocvvcolop";
                       str2, ' '));
// This code is contributed by Niharika Sahai



Time Complexity: O(n) 

Space Complexity: O(N),The recursion stack requires O(N) space. We are using additional space for the auxiliary string and the character variable.

Please refer complete article on Recursively remove all adjacent duplicates for more details!

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 17 Aug, 2023
Like Article
Save Article
Similar Reads
Complete Tutorials