Palindrome Permutation of a String in Java

A string inStr is provided to us. Our task is to find and print all the palindromes that is possible from the string inStr. Note that all of the characters of the string inStr have to be used to generate the palindromes. If a palindrome does not exist, then display an appropriate message.

Given a string, we need to print all possible palindromes that can be generated using letters of that string. Examples:

Example 1:

Input

String inStr = "ttpkkp"

Output

"ptkktp", "pkttkp", "tpkkpt", "tkppkt", "kpttpk", "ktpptk" are the palindromic permutation of the input string.

Explanation:

These are the only strings that have included all of the characters of the input string inStr and are also palindrome.

Example 2:

Input

String inStr = "kkbbckdkd"

Output

"kkbdcdbkk" "kkdbcbdkk" "kbkdcdkbk" "kbdkckdbk" "kdkbcbkdk" "kdbkckbdk" "bkkdcdkkb" "bkdkckdkb" "bdkkckkdb" "dkkbcbkkd" "dkbkckbkd" "dbkkckkbd"

Explanation:

These are the only strings that have included all of the characters of the input string inStr and are also palindrome.

Example 3:

Input

String inStr = "kkb"

Output

"kbk"

Explanation:

The only string "kbk" includes all of the characters of the input string inStr and is also a palindrome.

Simple Approach

The simple approach is to find out all the subsets of the string inStr. After that, filter out those subsets whose size is equal to the inStr. In the filtered-out subsets, check those subsets that are palindrome and print them.

FileName: PalindromePermutation.java

// importing HashSet, ArrayList, Iterator
// as they are required in the program

import java.util.HashSet;
import java.util.ArrayList;
import java.util.Iterator;

public class PalindromePermutation 
{
// a set that contains all the permutations
// of the string str1
HashSet<String> hSet;

// permuting the string str1
private void permuteString(String str1, int lt, int rt)
{
    // handling the base case
    if (lt == rt)
    {
        // storing the permuted string str1
        hSet.add(str1);
        
        return;
    }
    
    else 
    {
        // loop that does the permutation
        for (int j = lt; j <= rt; j++) 
        {
            str1 = strSwap(str1, lt, j);
            permuteString(str1, lt + 1, rt);
            str1 = strSwap(str1, lt, j);
        }
    }
}

// swapping the characters positioned at m and n
public String strSwap(String st1, int m, int n)
{
    char t;
    char[] charArr = st1.toCharArray();
    t = charArr[m];
    charArr[m] = charArr[n];
    charArr[n] = t;
    return String.valueOf(charArr);
}


// a method that checks whether the string str is 
// a palindrome or not
public boolean isPalindrome(String str)
{
    int i = 0; 
    int j = str.length() - 1;
    

    while(i <= j)
    {
        // if the characters do not match, return false
        // as the string str is not palindrome
        if(str.charAt(i) != str.charAt(j))
        {
            return false;
        }
        
        i = i + 1;
        j = j - 1;
    }
    
    return true;
}


// 
public ArrayList<String> palindromeStrings(String str) 
{
   // size of the input string str
   int size = str.length();
    
   permuteString(str, 0, size - 1);
   
   // list that stores the permuted palindrome string 
   ArrayList<String> ans = new ArrayList<String>( );
   
   // iterator for iterating over the hash set
   Iterator<String> itr = hSet.iterator();  
   while(itr.hasNext())  
   {  
    
    String temp = itr.next();
    
    if(isPalindrome(temp))
    {
        // if the control comes here,
        // then it means the string temp is a palindrome
        // and should be added to the list
        ans.add(temp);
    }
    
   }  
    
   return ans;
}
    

// main method
public static void main(String args[]) 
{
  // creating an object of the class PalindromePermutation
  PalindromePermutation obj = new PalindromePermutation();

  
  String inStr = "ttpkkp"; // input 1
  
  obj.hSet = new HashSet<String>();
  ArrayList<String> list = obj.palindromeStrings(inStr);
  System.out.println("For the string: " + inStr);
  System.out.println("The permutated palindrome strings are: ");
  for(int i = 0; i < list.size(); i++)
  {
      System.out.print(list.get(i) + " ");
  }
  
  System.out.println( "\n");
  
  inStr = "kkbbckdkd"; // input 2
  
  obj.hSet = new HashSet<String>();
  list = obj.palindromeStrings(inStr);
  System.out.println("For the string: " + inStr);
  System.out.println("The permutated palindrome strings are: ");
  for(int i = 0; i < list.size(); i++)
  {
      System.out.print(list.get(i) + " ");
  }
  
  System.out.println( "\n");
  
  inStr = "kkb"; // input 3
  
  obj.hSet = new HashSet<String>();
  list = obj.palindromeStrings(inStr);
  System.out.println("For the string: " + inStr);
  System.out.println("The permutated palindrome string is: ");
  for(int i = 0; i < list.size(); i++)
  {
      System.out.print(list.get(i) + " ");
  }

}
}

Output:

For the string: ttpkkp
The permutated palindrome strings are: 
kpttpk tpkkpt ktpptk ptkktp pkttkp tkppkt 

For the string: kkbbckdkd
The permutated palindrome strings are: 
kbdkckdbk bdkkckkdb kkbdcdbkk kdkbcbkdk dkkbcbkkd kdbkckbdk bkkdcdkkb kbkdcdkbk dbkkckkbd kkdbcbdkk dkbkckbkd bkdkckdkb 

For the string: kkb
The permutated palindrome string is: 
kbk

Complexity Analysis: The program is doing the permutation of the string. The program is also using loops. However, the permutation of the string is the main time-consuming process, which makes the time complexity of the program O(n!). Also, the program is using hash set to store the permutation of the input string. Thus, the space complexity of the program is also O(n! x n), where n is the total number of characters present in the input string.

After looking at the complexity analysis of the above program, it is obvious that some optimization is required. It is because the complexity of the above program is large. Before writing the program, let's see the following steps.

Step 1: First, it is required to check whether using the characters of the input string can generate a palindrome or not. If it is not possible to generate a palindrome, then return.

Step 2: After doing the checking in the first step, we can create the half part of the first palindrome string (lexicographically smallest) by considering the half frequency of each character of the input string.

Step 3: Now iterate through all of the permutations that are possible of the half string, and every time adds the reverse of this part at the end.

Step 4: Add the character having an odd frequency in between if the string is of the odd length for making the palindrome.

Now, observe the following program.

FileName: PalindromePermutation1.java

// importing HashSet, ArrayList, Iterator
// as they are required in the program

import java.util.HashSet;
import java.util.ArrayList;
import java.util.Iterator;

public class PalindromePermutation1 
{
// a set that contains all the permutation
// of the string str1
HashSet<String> hSet;

// permuting the string st1
private void permuteString(String str1, int lt, int rt)
{
// handling the base case
if (lt == rt)
{
// storing the permuted string str1
hSet.add(str1);

return;
}

else 
{
// loop that does the permutation
for (int j = lt; j <= rt; j++) 
{
    str1 = strSwap(str1, lt, j);
    permuteString(str1, lt + 1, rt);
    str1 = strSwap(str1, lt, j);
}
}
}

// swapping the characters positioned at m and n
public String strSwap(String st1, int m, int n)
{
char t;
char[] charArr = st1.toCharArray();
t = charArr[m];
charArr[m] = charArr[n];
charArr[n] = t;
return String.valueOf(charArr);
}


// A utility method for counting the frequencies and checking
// whether the character can make a palindrome or not
boolean isPalindrome(String str1, int freq[])
{
int len = str1.length();

// Updating frequency according to given string */
for (int j = 0; j < len; j++)
{
freq[str1.charAt(j) - 'a'] = freq[str1.charAt(j) - 'a'] + 1;
}

int oddFreq = 0;

// Loop for counting the total characters that have odd frequency
for (int j = 0; j < 26; j++)
{
if (freq[j] % 2 == 1)
{
	oddFreq = oddFreq + 1;
}
}

// Condition for Palindrome:
// if the length is odd, then only one character frequency has to be odd
// if the length is even, then no character frequency has to be odd
if ((len % 2 == 1 && oddFreq == 1 ) || (len % 2 == 0 && oddFreq == 0))
{
return true;
}
else
{
return false;
}
}

// Utility method for reversing a string
String reverse(String str1)
{
String rev = "";
for (int j = 0; j < str1.length(); j++)
{
char ch = str1.charAt(j); // stores the character
rev= ch + rev; // add the character ch in the beginning of the existing string
}

return rev;
}

// method for printing all of the possible palindromes by characters of
// the input strings
public ArrayList<String> palindromeStrings(String str)
{
int freq1[] = new int[26];
ArrayList<String> ansList = new ArrayList<String>();

// checking whether letter can make palindrome or not
if (!isPalindrome(str, freq1))
{
return ansList;
}

int len = str.length();

// half contains the half part of all the palindromes,
// It is the reason we are pushing the half freq of each 
// of the letter
String halfStr = "";
char oddChar = '\0';
for (int i = 0; i < 26; i++)
{
// The condition will be true at most once 
if(freq1[i] % 2 == 1)
{
	oddChar = (char)(i + 'a');
}
String t = "";
for(int j = 0; j < freq1[i] / 2; j++)
{
    t = t + (char)(i + 'a');
}

halfStr = halfStr + t;
}



permuteString(halfStr, 0, halfStr.length() - 1);

// palinStr keeps all possible palindromes
String palinStr = "";


// iterator for iterating over the hash set
Iterator<String> itr = hSet.iterator();  

// Now, iterating through all permutations of half and adding
// reverse part at the end.
// if the length is odd, then pushing oddCharacter also in mid
while(itr.hasNext())  
{  

String temp = itr.next();

palinStr = temp;
//System.out.println(reverse(temp));
if (len % 2 == 1)
{   
	palinStr = palinStr + oddChar;
}
palinStr = palinStr + reverse(temp);
ansList.add(palinStr);
}

return ansList;
}

// main method
public static void main(String args[]) 
{
// creating an object of the class PalindromePermutation1
PalindromePermutation1 obj = new PalindromePermutation1();


String inStr = "ttpkkp"; // input 1

obj.hSet = new HashSet<String>();
ArrayList<String> list = obj.palindromeStrings(inStr);
System.out.println("For the string: " + inStr);
System.out.println("The permutated palindrome strings are: ");
for(int i = 0; i < list.size(); i++)
{
System.out.print(list.get(i) + " ");
}

System.out.println( "\n");

inStr = "kkbbckdkd"; // input 2

obj.hSet = new HashSet<String>();
list = obj.palindromeStrings(inStr);
System.out.println("For the string: " + inStr);
System.out.println("The permutated palindrome strings are: ");
for(int i = 0; i < list.size(); i++)
{
System.out.print(list.get(i) + " ");
}

System.out.println( "\n");

inStr = "kkb"; // input 3

obj.hSet = new HashSet<String>();
list = obj.palindromeStrings(inStr);
System.out.println("For the string: " + inStr);
System.out.println("The permutated palindrome string is: ");
for(int i = 0; i < list.size(); i++)
{
System.out.print(list.get(i) + " ");
}

}
}

Output:

For the string: ttpkkp
The permutated palindrome strings are: 
ktpptk ptkktp pkttkp tkppkt kpttpk tpkkpt 

For the string: kkbbckdkd
The permutated palindrome strings are: 
dbkkckkbd kdbkckbdk kkbdcdbkk dkkbcbkkd kdkbcbkdk kbkdcdkbk bdkkckkdb bkkdcdkkb kbdkckdbk kkdbcbdkk bkdkckdkb dkbkckbkd 

For the string: kkb
The permutated palindrome string is: 
kbk

Complexity Analysis: The program is doing the permutation of half of the string. That makes the time complexity of the program O((n / 2)!). Also, the program is using hash set to store the permutation of the input string. Thus, the space complexity of the program is also O((n / 2)! x n / 2), where n is the total number of characters present in the input string.

Next TopicGrepcode java.util.Date

← prev next →