Mediana de dos arreglos ordenados

En este blog, te enseñaré cómo resolver el ejercicio Mediana de dos arreglos ordenados de la plataforma LeetCode en Java, Python, PHP, C++ y JavaScript en español.

En esta guía, aprenderás a:

✅ Una explicación del problema
✅ Una solución eficiente
✅ Implementaciones en Java, Python, PHP, C++ y JavaScript

Este ejercicio se encuentra en la plataforma de LeetCode como "Median of Two Sorted Arrays".

                       
Problema
Dados dos arrays ordenados, júntelos y retorne su mediana. La mediana es el valor central de la unión ambos arreglos.



Pasos para realizar el algoritmo:
1.- Se inicializan las siguientes variables:
✅ mediana1 y mediana2: Servirán para almacenar valores potenciales de las medianas de cada array. 

✅ tamaño1 y tamaño2: Se declaran para almacenar los tamaños de los arreglos.

✅ indice1 e indice2: Se utilizarán para mantener la posición cuando se recorran los arreglos.

2.- Se realiza un ciclo que se itera hasta la mitad de la unión de ambos arrays. Esto se hace ya que es suficiente para encontrar la mediana en el peor de los casos.

3.- Se asigna el valor actual de mediana2 a mediana1. Esto permite almacenar temporalmente la mediana encontrada en la iteración anterior mientras se procesa el siguiente elemento.

4.-✅ Se han agotado los elementos en nums1: Se toma el elemento actual de nums2 e incrementa indice2.

✅ Se han agotado los elementos en nums2 o el elemento actual en nums1 es menor que el de nums2: Se obtiene el elemento actual de nums1 e incrementa indice1.

✅ Si ninguno de los casos anteriores se cumple: Se toma el elemento actual de nums2 e incrementa indice2.

5.- Después del bucle, se verifica si la suma de los tamaños de ambos arreglos es par. Si es así, significa que hay dos valores medios. Por lo tanto, se calcula el promedio de ambas medianas y se devuelve con decimales. En caso contrario, se devuelve el valor de la mediana2.

Presentación

Código en Java

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {    
        //paso#1
        int mediana1=0, mediana2=0;
        int tamano1= nums1.length, tamano2=nums2.length;
        int indice1=0, indice2=0;
 
        //paso#2
        int finalRecorrido = (tamano1+tamano2)/2;
        for(int i=0; i<= finalRecorrido; i++){
            //paso#3
            mediana1= mediana2;
 
            //paso#4
            if(indice1>= tamano1)                                       
                mediana2= nums2[indice2++];
            else if(indice2>=tamano2 || nums1[indice1]< nums2[indice2]) 
                mediana2= nums1[indice1++];
            else if(indice2<tamano2)                                    
                mediana2= nums2[indice2++];       
        }
 
        //paso#5
        if((tamano1+tamano2)%2 ==0) return (float) (mediana1+mediana2)/2;
        else return mediana2;
    }
}

Código en php

class Solution {
 
    /**
     * @param Integer[] $nums1
     * @param Integer[] $nums2
     * @return Float
     */
    function findMedianSortedArrays($nums1, $nums2) {
        // Paso#1
        $mediana1 = 0;
        $mediana2 = 0;
        $tamano1 = count($nums1);
        $tamano2 = count($nums2);
        $indice1 = 0;
        $indice2 = 0;
 
        //Paso#2
        $finalRecorrido = (int) (($tamano1 + $tamano2) / 2);
        for ($i = 0; $i <= $finalRecorrido; $i++) {
 
         //Paso#3
            $mediana1 = $mediana2;
 
            //Paso#4
            if ($indice1 >= $tamano1) {
                $mediana2 = $nums2[$indice2++];
            } else if ($indice2 >= $tamano2 || $nums1[$indice1] < $nums2[$indice2]) {
                $mediana2 = $nums1[$indice1++];
            } else if ($indice2 < $tamano2) {
                $mediana2 = $nums2[$indice2++];
            }
        }
 
        //paso#5
        return ($tamano1 + $tamano2) % 2 === 0
        ? ($mediana1 + $mediana2) / 2
        : $mediana2;
    } 
}

Código en Python

class Solution:
    def findMedianSortedArrays(self, nums1, nums2):
        # paso #1
        mediana1 = 0
        mediana2 = 0
        tamano1 = len(nums1)
        tamano2 = len(nums2)
        indice1 = 0
        indice2 = 0
 
        # paso #2
        finalRecorrido = (tamano1 + tamano2) // 2
        for i in range(finalRecorrido + 1):
            # paso #3
            mediana1 = mediana2
 
            # paso #4
            if indice1 >= tamano1:
                mediana2 = nums2[indice2]
                indice2 += 1
            elif indice2 >= tamano2 or nums1[indice1] < nums2[indice2]:
                mediana2 = nums1[indice1]
                indice1 += 1
            else:
                mediana2 = nums2[indice2]
                indice2 += 1
 
        # paso #5
        if ((tamano1 + tamano2) % 2 == 0):
            return (mediana1 + mediana2) / 2.0
        else:
            return mediana2
 

Código en C++

class Solution {
public:
  double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
    // Paso #1
    int mediana1 = 0, mediana2 = 0;
    int tamano1 = nums1.size();;
    int tamano2 = nums2.size();
    int indice1 = 0;
    int indice2 = 0;
 
    // Paso #2
    int finalRecorrido = (tamano1 + tamano2) / 2;
    for (int i = 0; i <= finalRecorrido; i++) {
      // Paso #3
      mediana1 = mediana2;
 
      // Paso #4
      if (indice1 >= tamano1) {
        mediana2 = nums2[indice2++];
      } else if (indice2 >= tamano2 || nums1[indice1] < nums2[indice2]) {
        mediana2 = nums1[indice1++];
      } else if (indice2 < tamano2) {
        mediana2 = nums2[indice2++];
      }
    }
 
    // Paso #5
    if ((tamano1 + tamano2) % 2 == 0) {
      return (float)(mediana1 + mediana2) / 2;
    } else {
      return mediana2;
    }
  }
};

Código en JavaScript

/**
    * @param {number[]} nums1
    * @param {number[]} nums2
    * @return {number}
    */
   var findMedianSortedArrays = function(nums1, nums2) {
       // paso #1
       let mediana1 = 0;
       let mediana2 = 0;
       const tamano1 = nums1.length;
       const tamano2 = nums2.length;
       let indice1 = 0;
       let indice2 = 0;
    
       // paso #2
       const finalRecorrido = Math.floor((tamano1 + tamano2) / 2);
       for (let i = 0; i <= finalRecorrido; i++) {
         // paso #3
         mediana1 = mediana2;
    
         // paso #4
         if (indice1 >= tamano1) {
           mediana2 = nums2[indice2++];
         } else if (indice2 >= tamano2 || nums1[indice1] < nums2[indice2]) {
           mediana2 = nums1[indice1++];
         } else if (indice2 < tamano2) {
           mediana2 = nums2[indice2++];
         }
       }
    
       // paso #5
       if ((tamano1 + tamano2) % 2 === 0) {
         return (mediana1 + mediana2) / 2;
       } else {
         return mediana2;
       }
   };

        
    
Conclusión
En este blog, hemos visto cómo realizar el ejercicio Mediana de dos arreglos ordenados en Java, Python, PHP, C++ y JavaScript.

Hemos visto ejemplos de código en cada lenguaje de programación.