Programa Javascript para eliminar duplicados de una string dada

Dada una string S , la tarea es eliminar todos los duplicados en la string dada. 
A continuación se muestran los diferentes métodos para eliminar duplicados en una string.

<script>
 
// JavaScript program to remove duplicate character
// from character array and print in sorted
// order
function removeDuplicate(str, n)
    {
        // Used as index in the modified string
        var index = 0;
 
        // Traverse through all characters
        for (var i = 0; i < n; i++)
        {
 
            // Check if str[i] is present before it
            var j;
            for (j = 0; j < i; j++)
            {
                if (str[i] == str[j])
                {
                    break;
                }
            }
 
            // If not present, then add it to
            // result.
            if (j == i)
            {
                str[index++] = str[i];
            }
        }
         
        return str.join("").slice(str, index);
    }
 
    // Driver code
        var str = "geeksforgeeks".split("");
        var n = str.length;
        document.write(removeDuplicate(str, n));
     
// This code is contributed by shivanisinghss2110
 
</script>

Producción:  

geksfor

Complejidad de tiempo: O(n * n) 
Espacio auxiliar: O(1) 
Mantiene el orden de los elementos igual que la entrada. 

MÉTODO 2 (Usar BST)  conjunto
de uso que implementa un árbol de búsqueda binaria autoequilibrado. 

<script>
// javascript program to remove duplicate character
// from character array and print in sorted
// order
 
    function removeDuplicate( str , n)
    {
     
        // Create a set using String characters
        // excluding '�'
        var s = new Set();
         
        // HashSet doesn't allow repetition of elements
        for (var i = 0;i<n;i++)
            s.add(str[i]);
 
        // Print content of the set
        for (const v of s) {
 
            document.write(v);
    }
    }
 
    // Driver code
        var str = "geeksforgeeks";
        var n = str.length;
 
        removeDuplicate(str, n);
 
// This code is contributed by umadevi9616
</script>

Producción:  

  efgkors

Complejidad de Tiempo : O(n Log n) 
Espacio Auxiliar : O(n)

Gracias a Anivesh Tiwari por sugerir este enfoque.

No mantiene el orden de los elementos igual que la entrada, sino que los imprime ordenados.

MÉTODO 3 (Uso de clasificación)  
Algoritmo: 

  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.

Ejemplo:  

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

Tenga en cuenta que este método no mantiene el orden original de la string de entrada. Por ejemplo, si vamos a eliminar los duplicados de geeksforgeeks y mantener el mismo orden de los caracteres, la salida debería ser geksfor, pero la función anterior devuelve efgkos. Podemos modificar este método almacenando el pedido original.

Implementación:  

<script>
 
function removeDuplicate(string)
{
   return string.split('')
    .filter(function(item, pos, self)
    {
      return self.indexOf(item) == pos;
    }
   ).join('');
}
 
var str = "geeksforgeeks";
document.write( " "+removeDuplicate(str));
 
//This code is contributed by SoumikMondal
</script>

Producción:  

efgkors

Complejidad de tiempo: O (n log n) Si usamos algún algoritmo de clasificación nlogn en lugar de quicksort.

Espacio Auxiliar: O(1)

MÉTODO 4 (Usar hash) 

Algoritmo:  

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 stringing" */
3: Remove extra characters at the end of the resultant string.
  /*  String obtained after this step is "te string" */

Implementación:  

<script>
// javascript program to remove duplicates
    /*
     * Function removes duplicate characters from the string This function work
     * in-place
     */
    function removeDuplicates( str) {
        var lhs = new Set();
        for (var i = 0; i < str.length; i++)
            lhs.add(str[i]);
 
        // print string after deleting duplicate elements
        for (var ch of lhs)
            document.write(ch);
    }
 
    /* Driver program to test removeDuplicates */
     
        var str = "geeksforgeeks";
        removeDuplicates(str);
 
// This code is contributed by umadevi9616
</script>

Producción:  

geksfor

Complejidad de tiempo: O(n)

Puntos importantes:  

• El método 2 no mantiene los caracteres como strings originales, pero el método 4 sí.
• Se supone que el número de caracteres posibles en la string de entrada es 256. NO_OF_CHARS debe cambiarse en consecuencia.
• calloc() se usa en lugar de malloc() para las asignaciones de memoria de una array de conteo (recuento) para inicializar la memoria asignada a ‘�’. También se puede usar malloc() seguido de memset().
• El algoritmo anterior también funciona para entradas de array de enteros si se proporciona el rango de los enteros en la array. Un problema de ejemplo es encontrar el número máximo que ocurre en una array de entrada dado que la array de entrada contiene números enteros solo entre 1000 y 1100

Método 5 (usando el método IndexOf() ): 
requisito previo: método Java IndexOf()  

<script>
 
    // JavaScript program to create a unique string
     
    // Function to make the string unique
    function unique(s)
    {
        let str = "";
        let len = s.length;
          
        // loop to traverse the string and
        // check for repeating chars using
        // IndexOf() method in Java
        for (let i = 0; i < len; i++)
        {
            // character at i'th index of s
            let c = s[i];
              
            // if c is present in str, it returns
            // the index of c, else it returns -1
            if (str.indexOf(c) < 0)
            {
                // adding c to str if -1 is returned
                str += c;
            }
        }
          
        return str;
    }
     
      // Input string with repeating chars
    let s = "geeksforgeeks";
 
    document.write(unique(s));
     
</script>

Producción:  

geksfor

Gracias debjitdbb por sugerir este enfoque.
 

Método 6 (usando el método STL unordered_map ): 
Requisito previo: método C++ unordered_map STL  

<script>
// javascript program to create a unique String using unordered_map
 
/* access time in unordered_map on is O(1) generally if no collisions occur
and therefore it helps us check if an element exists in a String in O(1)
time complexity with constant space. */
     function removeDuplicates( s , n) {
        var exists = new Map();
 
        var st = "";
        for (var i = 0; i < n; i++) {
            if (!exists.has(s[i])) {
                st += s[i];
                exists.set(s[i], 1);
            }
        }
        return st;
    }
 
    // driver code
     
        var s = "geeksforgeeks";
        var n = s.length;
        document.write(removeDuplicates(s, n));
// This code contributed by umadevi9616
</script>

Producción:  

geksfor

Complejidad de tiempo: O(n) 
Espacio auxiliar: O(n)
Gracias, Allen James Vinoy por sugerir este enfoque.
 

Consulte el artículo completo sobre Eliminar duplicados de una string determinada para obtener más detalles.