# Remove all duplicates from a given string

Below are the different methods to remove duplicates in a string.

METHOD 1 (Use Sorting)

Algorithm:

1) Sort the elements.
2) Now in a loop, remove duplicates by comparing the
current character with previous character.
3)  Remove extra characters at the end of the resultant string.

Example:

Input string:  geeksforgeeks
1) Sort the characters
2) Remove duplicates
3) Remove extra characters
efgkors

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Note that, this method doesn’t keep the original order of the input string. For example, if we are to remove duplicates for geeksforgeeks and keep the order of characters same, then output should be geksfor, but above function returns efgkos. We can modify this method by storing the original order. METHOD 2 keeps the order same.

Implementation:

## C++

// C++ prigram to remove duplicates, the order of
// characters is not maintained in this program
#include<bits/stdc++.h>
using namespace std;

/* Function to remove duplicates in a sorted array */
char *removeDupsSorted(char *str)
{
int res_ind = 1, ip_ind = 1;

/* In place removal of duplicate characters*/
while (*(str + ip_ind))
{
if (*(str + ip_ind) != *(str + ip_ind - 1))
{
*(str + res_ind) = *(str + ip_ind);
res_ind++;
}
ip_ind++;
}

/* After above step string is efgkorskkorss.
Removing extra kkorss after string*/
*(str + res_ind) = '\0';

return str;
}

/* Function removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
char *removeDups(char *str)
{
int n = strlen(str);

// Sort the character array
sort(str, str+n);

// Remove duplicates from sorted
return removeDupsSorted(str);
}

/* Driver program to test removeDups */
int main()
{
char str[] = "geeksforgeeks";
cout << removeDups(str);
return 0;
}

## Java

// Java program to remove duplicates, the order of
// characters is not maintained in this program

import java.util.Arrays;

public class GFG
{
/* Method to remove duplicates in a sorted array */
static String removeDupsSorted(String str)
{
int res_ind = 1, ip_ind = 1;

// Character array for removal of duplicate characters
char arr[] = str.toCharArray();

/* In place removal of duplicate characters*/
while (ip_ind != arr.length)
{
if(arr[ip_ind] != arr[ip_ind-1])
{
arr[res_ind] = arr[ip_ind];
res_ind++;
}
ip_ind++;

}

str = new String(arr);
return str.substring(0,res_ind);
}

/* Method removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
static String removeDups(String str)
{
// Sort the character array
char temp[] = str.toCharArray();
Arrays.sort(temp);
str = new String(temp);

// Remove duplicates from sorted
return removeDupsSorted(str);
}

// Driver Method
public static void main(String[] args)
{
String str = "geeksforgeeks";
System.out.println(removeDups(str));
}
}

## C

// C++ program to remove duplicates, the order of
// characters is not maintained in this program
# include <stdio.h>
# include <stdlib.h>

/* Function to remove duplicates in a sorted array */
char *removeDupsSorted(char *str);

/* Utitlity function to sort array A[] */
void quickSort(char A[], int si, int ei);

/* Function removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
char *removeDups(char *str)
{
int len = strlen(str);
quickSort(str, 0, len-1);
return removeDupsSorted(str);
}

/* Function to remove duplicates in a sorted array */
char *removeDupsSorted(char *str)
{
int res_ind = 1, ip_ind = 1;

/* In place removal of duplicate characters*/
while (*(str + ip_ind))
{
if (*(str + ip_ind) != *(str + ip_ind - 1))
{
*(str + res_ind) = *(str + ip_ind);
res_ind++;
}
ip_ind++;
}

/* After above step string is efgkorskkorss.
Removing extra kkorss after string*/
*(str + res_ind) = '\0';

return str;
}

/* Driver program to test removeDups */
int main()
{
char str[] = "geeksforgeeks";
printf("%s", removeDups(str));
getchar();
return 0;
}

/* FOLLOWING FUNCTIONS ARE ONLY FOR SORTING
PURPOSE */
void exchange(char *a, char *b)
{
char temp;
temp = *a;
*a   = *b;
*b   = temp;
}

int partition(char A[], int si, int ei)
{
char x = A[ei];
int i = (si - 1);
int j;

for (j = si; j <= ei - 1; j++)
{
if (A[j] <= x)
{
i++;
exchange(&A[i], &A[j]);
}
}
exchange (&A[i + 1], &A[ei]);
return (i + 1);
}

/* Implementation of Quick Sort
A[] --> Array to be sorted
si  --> Starting index
ei  --> Ending index
*/
void quickSort(char A[], int si, int ei)
{
int pi;    /* Partitioning index */
if (si < ei)
{
pi = partition(A, si, ei);
quickSort(A, si, pi - 1);
quickSort(A, pi + 1, ei);
}
}

]

## Python

# Python program to remove duplicates, the order of
# characters is not maintained in this program

# Utility function to convert string to list
def toMutable(string):
temp = []
for x in string:
temp.append(x)
return temp

# Utility function to convert string to list
def toString(List):
return ''.join(List)

# Function to remove duplicates in a sorted array
def removeDupsSorted(List):
res_ind = 1
ip_ind = 1

# In place removal of duplicate characters
while ip_ind != len(List):
if List[ip_ind] != List[ip_ind-1]:
List[res_ind] = List[ip_ind]
res_ind += 1
ip_ind+=1

# After above step string is efgkorskkorss.
# Removing extra kkorss after string
string = toString(List[0:res_ind])

return string

# Function removes duplicate characters from the string
# This function work in-place and fills null characters
# in the extra space left
def removeDups(string):
# Convert string to list
List = toMutable(string)

# Sort the character list
List.sort()

# Remove duplicates from sorted
return removeDupsSorted(List)

# Driver program to test the above functions
string = "geeksforgeeks"
print removeDups(string)

# This code is contributed by Bhavya Jain

Output:

efgkors

Time Complexity: O(nlogn) If we use some nlogn sorting algorithm instead of quicksort.

METHOD 2 (Use Hashing )

Algorithm:

1: Initialize:
str  =  "test string" /* input string */
ip_ind =  0          /* index to  keep track of location of next
character in input string */
res_ind  =  0         /* index to  keep track of location of
next character in the resultant string */
bin_hash[0..255] = {0,0, ….} /* Binary hash to see if character is
already processed or not */
2: Do following for each character *(str + ip_ind) in input string:
(a) if bin_hash is not set for *(str + ip_ind) then
// if program sees the character *(str + ip_ind) first time
(i)  Set bin_hash for *(str + ip_ind)
(ii)  Move *(str  + ip_ind) to the resultant string.
This is done in-place.
(iii) res_ind++
(b) ip_ind++
/* String obtained after this step is "te sringng" */
3: Remove extra characters at the end of the resultant string.
/*  String obtained after this step is "te sring" */

Implementation:

## C

# include <stdio.h>
# include <stdlib.h>
# define NO_OF_CHARS 256
# define bool int

/* Function removes duplicate characters from the string
This function work in-place and fills null characters
in the extra space left */
char *removeDups(char *str)
{
bool bin_hash[NO_OF_CHARS] = {0};
int ip_ind = 0, res_ind = 0;
char temp;

/* In place removal of duplicate characters*/
while (*(str + ip_ind))
{
temp = *(str + ip_ind);
if (bin_hash[temp] == 0)
{
bin_hash[temp] = 1;
*(str + res_ind) = *(str + ip_ind);
res_ind++;
}
ip_ind++;
}

/* After above step string is stringiittg.
Removing extra iittg after string*/
*(str+res_ind) = '\0';

return str;
}

/* Driver program to test removeDups */
int main()
{
char str[] = "geeksforgeeks";
printf("%s", removeDups(str));
getchar();
return 0;
}

## Java

// Java prigram to remove duplicates
import java.util.*;

class RemoveDuplicates
{
/* Function removes duplicate characters from the string
This function work in-place */
void removeDuplicates(String str)
{
for(int i=0;i<str.length();i++)

// print string after deleting duplicate elements
for(Character ch : lhs)
System.out.print(ch);
}

/* Driver program to test removeDuplicates */
public static void main(String args[])
{
String str = "geeksforgeeks";
RemoveDuplicates r = new RemoveDuplicates();
r.removeDuplicates(str);
}
}

// This code has been contributed by Amit Khandelwal (Amit Khandelwal 1)

## Python

# Python program to remvoe duplicate characters from an
# input string
NO_OF_CHARS = 256

# Since strings in Python are immutable and cannot be changed
# This utility function will convert the string to list
def toMutable(string):
List = []
for i in string:
List.append(i)
return List

# Utility function that changes list to string
def toString(List):
return ''.join(List)

# Function removes duplicate characters from the string
# This function work in-place and fills null characters
# in the extra space left
def removeDups(string):
bin_hash = [0] * NO_OF_CHARS
ip_ind = 0
res_ind = 0
temp = ''
mutableString = toMutable(string)

# In place removal of duplicate characters
while ip_ind != len(mutableString):
temp = mutableString[ip_ind]
if bin_hash[ord(temp)] == 0:
bin_hash[ord(temp)] = 1
mutableString[res_ind] = mutableString[ip_ind]
res_ind+=1
ip_ind+=1

# After above step string is stringiittg.
# Removing extra iittg after string

# Driver program to test the above functions
string = "geeksforgeeks"
print removeDups(string)

# A shorter version for this program is as follows
# import collections
# print ''.join(collections.OrderedDict.fromkeys(string))

# This code is contributed by Bhavya Jain

Output:

geksfor

Time Complexity: O(n)

Important Points:

• Method 1 doesn’t maintain order of characters as original string, but method 2 does.
• It is assumed that number of possible characters in input string are 256. NO_OF_CHARS should be changed accordingly.
• calloc is used instead of malloc for memory allocations of counting array (count) to initialize allocated memory to ‘\0’. malloc() followed by memset() could also be used.
• Above algorithm also works for an integer array inputs if range of the integers in array is given. Example problem is to find maximum occurring number in an input array given that the input array contain integers only between 1000 to 1100

# GATE CS Corner    Company Wise Coding Practice

1.8 Average Difficulty : 1.8/5.0
Based on 118 vote(s)