El enunciado no indica que los vectores que se ingresan estan ordenados, que parece ser asumido por las soluciones presentadas.
Refundir un contenido sin ordenar, supone una de tres cosas:
A ) Se concatena el contenido de ambios arrays y luego se ordena ese array.E perfectamente válido pero no es lo que se solicita en el enunciado.
Es trivial este caso, siendo el ejercicio de un estudiante carece de interés, porque no ofrece nada más interesante que ordenar un array.
Si el estudiante está tratando de aprender a concatenar arrays, ordenarlo después es exigirle en tal momento demasiado.
Si el estudiante ya sabe ordenar un array, concatenar dos arrays, debe serle sencillo pero dicha trivialidad distrae de lo que realmente se trata de enseñar/aprender.
B ) Los arrays no están ordenados, pero todavía se refunde ordenadamente.Este caso, es bastante más ineficaz de cara al rendimiento, pués para ordenar sobre la marcha, ambos arrays, no se presta fácilmente cualquier algoritmo.
Los más aptos son aquellos que en cada iteración van dejando ordenado uno de sus extremos, como es el caso por ejemplo del algoritmo 'Selection Sort'.
Mezclar el algortimo de refundición (que en sí mismo es un algoritmo de ordenamiento), con otro de ordenamiento, solo oscurece el código resultante al tiempo que se le priva de la eficacia de 'pasar' previamente los arrays por un algoritmo más eficiente.
De todos modos, para despejar dudas se propone una implementación en pseudocódigo para este caso, es básicamente el pseudocódigo anterior mezclado con el algoritmo selection sort.
El algoritmo 'Selection-sort' es el que mejor acomoda a la situación sin complicar en exceso el algoritmo final, dado que 'Selection' puede entenderse como un algoritmo de dos pasos:
Puede exhibirse un caso procediendo con la refundición estando aún los arrays desordenados, para ello, se procede a buscar los elementos mayores (o menores en sendos arrays).
entero j, k, n, sizeA, sizeB
entero vA, vB, tmp
sizeA = size(arrayA)
sizeB = size(arrayB)
entero arrSalida(0 a sizeA + sizeB -1)
// buscar el mayor en el arrayB, entre la posición tmp (K) y sizeB, e intercambiar valores entre las posiciones tmp y k.
tmp = k
vB = BuscarValorMayor(arrayB, tmp, sizeB)
arrayB(tmp) = arrayB(k): arrayB(k) = vb // poco a poco se va ordenando el arrayB
Hacer mientras (limite = 0)
// buscar el mayor en el arrayA, entre la posición tmp (j) y sizeA, e intercambiar valores entre las posiciones tmp y j.
tmp = j
vA = BuscarValorMayor(arrayA, tmp, sizeA)
arrayA(tmp) = arrayA(j): arrayA(j) = vA // poco a poco se va ordenando el arrayA
Hacer mientras (vA => vB)
arrSalida(n) = vA
n +=1
j +=1
si (j> sizeA)
limite=1 // señalaría que el arrayB debe depositar lo que reste en salida
// podría hacerse aquí, pero queda más claro si se hace fuera de ambos bucles.
salir del bucle
fin si
tmp = j
vA = BuscarValorMayor(arrayA, tmp, sizeA)
arrayA(tmp) = arrayA(j): arrayA(j) = vA
repetir
si limite = 0
Hacer mientras (vB > vA)
arrSalida(n) = vB
n +=1
k +=1
si (k> sizeB)
limite=2 // señalaría que el arrayB debe depositar lo que reste en salida
// podría hacerse aquí, pero queda más claro si se hace fuera de ambos bucles.
salir del bucle
fin si
tmp = k
vB = BuscarValorMayor(arrayB, tmp, sizeB)
arrayB(tmp) = arrayB(k): arrayB(k) = vb
repetir
fin si
repetir
Si limite = 1
bucle para k desde k hasta sizeB
tmp = k
vB = BuscarValorMayor(arrayB, tmp, sizeB)
arrayB(tmp) = arrayB(k): arrayB(k) = vb
arrSalida(n) = vB
n +=1
k +=1
siguiente
sino // limite = 2
bucle para j desde j hasta sizeA
tmp = j
vA = BuscarValorMayor(arrayA, tmp, sizeA)
arrayA(tmp) = arrayA(j): arrayA(j) = vA
arrSalida(n) = vA
n +=1
j +=1
siguiente
fin si
A continuación se presenta el algoritmo SelectionSort expuesto en la forma de dos pasos, para terminar de entender como opera.
No obstante se puede ver como complica innecesariamente acometer el ordenamiento de ambos arrays al tiempo que se procede con la refundición y como decía, al tiempo que se priva ordenar ambos arrays por un algoritmo mucho más eficiente.
La máxima 'divide y vencerás', no es trivial en programación...
He aquí el algoritmo expuesto en esos dos pasos...
Se propone al tiempo dos parámetros para ordenar solo un rango específico del array (pués no lo hace distintto ni más complejo), y que, en caso del rango completo sus valores serán 0 y el tamaño del array -1.
Funcion Selectionsort(array de enteros Matriz(), entero Min, entero Max )
entero k, t
Hacer mientras (Min < Max)
k = Min
t = BuscarValorMayor(Matriz, k, Max) // 'k' es pasado por referencia, con lo que a su vuelta es contiene el índice que ocupa el valor devuelto.
Matriz(k) = Matriz(Min): Matriz(Min) = t
Min += 1
Siguiente
Fin funcion
Y aquí la funció que localiza el mayor en un array, que tampoco tiene más complejidad...
Baste decir que por eficiencia, devuelve tanto el valor como el índice de dicho valor.
entero = Funcion BuscarValorMayor(array de enteros Matriz(), entero *Desde , entero Hasta)
entero i, v
v = Matriz(Desde)
i = (Desde + 1)
Hacer mientras (i <= Hasta)
Si (Matriz(i) > v) Then // si enésimo es mayor que el actual mayor...
Desde = i: v = Matriz(i) // recordamos índice y valor.
fin si
i += 1
Siguiente
devolver v
Fin funcion
Por razones de eficiencia es habitual no separar el algoritmo en dos funciones sino hacer la búsqueda del mayor/menor en el rango restante, in situ, razón quizás por la que no se repare en su sencillez.
C ) Que ambos arrays deben estar ordenados antes de proceder a la refundición.Así que sí, es razonablemente correcto asumir por defecto este caso.
Bien es cierto, que faltaba una aclaración al respecto al menos, aunque debiera ser deducible por el interesado.
Autor
En línea
