¿Unir arrays ordenados?

Answer

1. 

   davy.ai

   July 30, 2023 at 10:31 pm

   Para fusionar e imprimir dos arreglos ordenados sin duplicados, puedes usar un enfoque similar a la fusión de dos arreglos. Antes de agregar un elemento al nuevo arreglo, puedes verificar si ya existe en el nuevo arreglo. Si existe, puedes omitirlo y pasar al siguiente elemento. Aquí tienes un ejemplo de fragmento de código que demuestra este enfoque:

   public static void mergeAndPrintSortedArrays(int[] a, int[] b) {
       int[] merged = new int[a.length + b.length];
       int i = 0, j = 0, k = 0;
   
       while (i < a.length && j < b.length) {
           if (a[i] < b[j]) {
               if (i == 0 || a[i] != a[i - 1]) { // Verificar duplicados
                   merged[k++] = a[i++];
               } else {
                   i++;
               }
           } else {
               if (j == 0 || b[j] != b[j - 1]) { // Verificar duplicados
                   merged[k++] = b[j++];
               } else {
                   j++;
               }
           }
       }
   
       while (i < a.length) {
           if (i == 0 || a[i] != a[i - 1]) { // Verificar duplicados
               merged[k++] = a[i++];
           } else {
               i++;
           }
       }
   
       while (j < b.length) {
           if (j == 0 || b[j] != b[j - 1]) { // Verificar duplicados
               merged[k++] = b[j++];
           } else {
               j++;
           }
       }
   
       for (int x = 0; x < k; x++) {
           System.out.print(merged[x] + " ");
       }
   }
   

   En esta implementación, creamos un nuevo arreglo llamado merged para almacenar los elementos fusionados y sin duplicados de los dos arreglos de entrada. Luego, utilizamos tres bucles while para iterar a través de a, b y merged, respectivamente. Las variables i, j y k llevan un seguimiento de la posición actual en cada arreglo.

   Dentro del primer bucle while, comparamos los elementos actuales de a y b. Si a[i] es menor que b[j], verificamos si es un duplicado comparándolo con el elemento anterior en merged. Si no es un duplicado, lo agregamos al arreglo merged e incrementamos i y k. Si es un duplicado, simplemente incrementamos i y pasamos al siguiente elemento.

   Si b[j] es menor que a[i], realizamos una verificación similar para duplicados, pero con el arreglo b en lugar de a. Si ambos elementos son iguales, agregamos cualquiera de los dos a merged (ya que ambos están sin duplicados).

   Los dos últimos bucles while manejan los elementos restantes en a o b. Realizan las mismas verificaciones de eliminación de duplicados que en el primer bucle.

   Finalmente, utilizamos un bucle for para imprimir los elementos de merged. Ten en cuenta que solo imprimimos hasta k, ya que el arreglo podría contener ceros adicionales al final.

Comments are closed.