diff --git a/concurrencia/python/Async/Busqueda_CRCW.py b/concurrencia/python/Async/Busqueda_CRCW.py
new file mode 100644
index 0000000..dd69fc7
--- /dev/null
+++ b/concurrencia/python/Async/Busqueda_CRCW.py
@@ -0,0 +1,42 @@
+import asyncio
+
+global A, Amin
+
+def leer():
+    # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+# Función que realiza la suma de dos elementos en un arreglo
+async def com(p1, p2):
+    global A, Amin
+    if A[p1-1] >= A[p2-1]:
+        Amin[p1-1] = 1
+    else:
+        Amin[p2-1] = 1
+    print(Amin)
+
+async def asign(i):
+    global A, Amin
+    if Amin[i-1] == 0:
+        print(f'El menor es {A[i-1]} en la posición {i}')
+
+async def main():
+    global A, Amin
+    A = leer()
+    n2 = len(A)
+    Amin = [0] * len(A)
+    P = [(i, j) for i in range(1, n2+1) for j in range(i+1, n2+1)]
+    await asyncio.gather(*[com(*pos) for pos in P])
+    P = [i for i in range(1, n2+1)]
+    await asyncio.gather(*[asign(pos) for pos in P])
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/concurrencia/python/Async/MinimoEREW.py b/concurrencia/python/Async/MinimoEREW.py
new file mode 100644
index 0000000..477522a
--- /dev/null
+++ b/concurrencia/python/Async/MinimoEREW.py
@@ -0,0 +1,56 @@
+import asyncio
+import math
+import time
+
+global A, s
+
+
+def leer():
+    # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+async def ordenar(p1, p2):
+    global A
+    if A[p1] == 'Infinito' and A[p2] == 'Infinito':
+        pass
+    elif A[p1] != 'Infinito':
+        pass
+    else:
+        A[p1] = A[p2]
+    if A[p1] != 'Infinito' and A[p2] != 'Infinito' and A[p2] >= A[p1]:
+        A[p2] = 'Infinito'
+    else:
+        A[p1] = A[p2]
+        A[p2] = 'Infinito'
+    print(A)
+
+
+async def main():
+    global A, s
+    p = 'No'
+    A = leer()
+    n = int(math.log2(len(A)))
+    n2 = len(A)
+    s = time.time()
+    print(A)
+    for i in range(1, n + 1):
+        print('Paso nuevo ' + str(i))
+        k = pow(2, i)
+        k0 = int(k / 2)
+        m = int(n2 / k)
+        P = [(n2 - j * k, n2 + k0 - j * k) for j in range(1, m + 1)]
+        print(P)
+        await asyncio.gather(*[ordenar(*pos) for pos in P])
+    print(f'Mínimo es {A[0]}')
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/concurrencia/python/Async/OddEvenMerge.py b/concurrencia/python/Async/OddEvenMerge.py
new file mode 100644
index 0000000..e5d6a2d
--- /dev/null
+++ b/concurrencia/python/Async/OddEvenMerge.py
@@ -0,0 +1,83 @@
+import numpy as np
+import asyncio
+import time
+
+async def print_arr(aux, p_i, l):
+    print("\n [", end="")
+    for i in range(l):
+        p = i + p_i
+        print(f"{aux[p]:.6f}, ", end="")
+    print("]")
+
+async def odd_even_split(aux, odd, even, i):
+    odd[i] = aux[2*i+1]
+    even[i] = aux[2*i]
+    print(f'split {2*i+1} y {2*i}')
+
+async def unir(aux, odd, even, i):
+    aux[2*i+1] = odd[i]
+    aux[2*i] = even[i]
+    print(f'unir {2*i+1} y {2*i}')
+
+async def comparar(aux,i):
+    print(f'comparar {2*i-1} y {2*i}')
+    if aux[2*i-1] > aux[2*i]:
+        aux[2*i-1], aux[2*i] = aux[2*i], aux[2*i-1]
+
+async def odd_even_merge(aux, l):
+    print(f'odd-even-merge {aux}')
+    if l == 2:
+        if aux[0] > aux[1]:
+            aux[0], aux[1] = aux[1], aux[0]
+    else:
+        m = l // 2
+        
+        odd = np.zeros(m)
+        even = np.zeros(m)
+        tasks = []
+        for i in range(m):
+            tasks.append(odd_even_split(aux, odd, even, i))
+        await asyncio.gather(*tasks)
+        
+        tasks = []
+        tasks.append(odd_even_merge(odd, m))
+        tasks.append(odd_even_merge(even, m))
+        await asyncio.gather(*tasks)
+        
+        tasks = []
+        for i in range(m):
+            tasks.append(unir(aux, odd, even, i))
+        await asyncio.gather(*tasks)
+        
+        tasks = []
+        for i in range(1, m):
+            tasks.append(comparar(aux, i))
+        await asyncio.gather(*tasks)
+
+async def odd_even_merge_sort(aux, l):
+    if l > 1:
+        print(f'odd-even-merge-sort {aux}')
+        m = l // 2
+        tasks = []
+        tasks.append(odd_even_merge_sort(aux[:m], m))
+        tasks.append(odd_even_merge_sort(aux[m:], m))
+        await asyncio.gather(*tasks)
+        await odd_even_merge(aux, l)
+
+async def main():
+    n1 = int(input("Ingrese la potencia k, para 2^k renglones de 1 a 10: "))
+    n2 = 2 ** n1
+    print(f"Ordenar vector de {n2}")
+    L = np.zeros(n2)
+    print("Ingresar V")
+    for i in range(n2):
+        L[i] = float(input(f"Ingresar V[{i+1}]: "))
+    start_time = time.time()
+    await odd_even_merge_sort(L, n2)
+    end_time = time.time()
+    print("\nTiempo de ejecución:", end_time - start_time, "segundos")
+    print("\nEl vector resultante:")
+    await print_arr(L, 0, n2)
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/concurrencia/python/Async/Ordenamiento_CRCW.py b/concurrencia/python/Async/Ordenamiento_CRCW.py
new file mode 100644
index 0000000..f0116cd
--- /dev/null
+++ b/concurrencia/python/Async/Ordenamiento_CRCW.py
@@ -0,0 +1,51 @@
+import asyncio
+
+global A,Aord, A1
+
+def leer():
+     # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+# Función que realiza la suma de dos elementos en un arreglo
+async def com(p1, p2):
+
+    global A,Aord
+
+    if A[p1-1]>=A[p2-1]:
+        Aord[p1-1] +=1
+    else:
+        Aord[p2-1] +=1
+    print(Aord)
+
+async def asign(i):
+    global A, A1
+    A1[Aord[i-1]]= A[i-1]
+    print(A1)
+
+
+async def main():
+
+    global A,Aord, A1
+
+    A = leer()
+    n2 = len(A)
+    Aord = [0]*len(A)
+    A1 = [0]*len(A)
+    P = [(i,j) for i in range(1, n2+1) for j in range(i+1,n2+1)]
+    await asyncio.gather(*[com(*pos) for pos in P])
+
+    P = [i for i in range(1,n2+1)]
+    await asyncio.gather(*[asign(i) for i in P])
+    
+    print(f'El arreglo ordenado {A1}')
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/concurrencia/python/Async/busquedaEREW.py b/concurrencia/python/Async/busquedaEREW.py
new file mode 100644
index 0000000..ca7d149
--- /dev/null
+++ b/concurrencia/python/Async/busquedaEREW.py
@@ -0,0 +1,63 @@
+import asyncio
+import math
+import time
+
+global A, Aux, s, p
+
+
+def leer():
+    # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+
+async def llenar(p1, p2):
+    global Aux
+    Aux[p2 - 1] = Aux[p1 - 1]
+
+
+# Función que realiza la suma de dos elementos en un arreglo
+async def cmp(p1):
+    global A, Aux, p
+    if (Aux[p1 - 1] != A[p1 - 1]):
+        A[p1 - 1] = 'Infinito'
+    else:
+        p = p1
+    print(A)
+
+async def main():
+    global A, Aux, s, p
+    p = 'No'
+    A = leer()
+    n = int(math.log2(len(A)))
+    n2 = len(A)
+    s = time.time()
+    Aux = [0] * n2
+    Aux[0] = float(input(f"Ingrea el elemento a buscar: "))
+    print(Aux)
+    for i in range(1, n + 1):
+        print('Paso ' + str(i))
+        k = pow(2, i)
+        k0 = int(k / 2)
+        P = [(j, j + k0) for j in range(1, k0 + 1)]
+        await asyncio.gather(*[llenar(*pos) for pos in P])
+        print(Aux)
+    P = [j for j in range(1, n2 + 1)]
+    print(P)
+    await asyncio.gather(*[cmp(pos) for pos in P])
+    print(A)
+    if p == 'No encontrado':
+        print(p)
+    else:
+        print(f'encontrado en {p}')
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/concurrencia/python/Async/matriz.py b/concurrencia/python/Async/matriz.py
new file mode 100644
index 0000000..a518c9a
--- /dev/null
+++ b/concurrencia/python/Async/matriz.py
@@ -0,0 +1,54 @@
+import asyncio
+import math
+
+global A, B, C
+
+def leer_matriz(f):
+    # Pedir al usuario el número de filas y columnas de la matriz
+    filas = f
+    # Crear una matriz vacía
+    matriz = []
+    # Pedir al usuario que ingrese los elementos de la matriz uno por uno
+    print("Ingrese los elementos de la matriz, fila por fila:")
+    for i in range(filas):
+        fila = []
+        for j in range(filas):
+            elemento = float(input(f"Elemento en la posición ({i + 1}, {j + 1}): "))
+            fila.append(elemento)
+        matriz.append(fila)
+    # Mostrar la matriz
+    print("La matriz ingresada es:")
+    for fila in matriz:
+        print(fila)
+    return matriz
+
+async def llenar(i, j, k):
+    global A, B, C
+    C[i][j][k] = A[i][k] * B[k][j]
+
+async def sumar(i, j, k, s):
+    global C
+    if (2 * k) % pow(2, s) == 0:
+        C[i - 1][j - 1][2 * k - 1] += C[i - 1][j - 1][2 * k - int(pow(2, s - 1)) - 1]
+
+async def main():
+    global A, B, C
+    f = int(input("Ingrese el número de filas/columnas de la matriz: "))
+    A = leer_matriz(f)
+    B = leer_matriz(f)
+    C = [[[0.0 for _ in range(f)] for _ in range(f)] for _ in range(f)]
+    P = [(i, j, k) for i in range(0, f) for j in range(0, f) for k in range(0, f)]
+    await asyncio.gather(*[llenar(*pos) for pos in P])
+    for s in range(0, int(math.log2(f))):
+        P = [(i + 1, j + 1, k + 1, s + 1) for i in range(0, f) for j in range(0, f) for k in range(0, int(f / 2))]
+        await asyncio.gather(*[sumar(*pos) for pos in P])
+    s = ''
+    for m in range(0, f):
+        s += '['
+        for n in range(0, f):
+            s = s + str(C[m][n][f - 1]) + ', '
+        s += ']\n'
+    print(f'\n La matriz A*B es: \n {s}')
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/concurrencia/python/Async/sumaCrew.py b/concurrencia/python/Async/sumaCrew.py
new file mode 100644
index 0000000..6b35522
--- /dev/null
+++ b/concurrencia/python/Async/sumaCrew.py
@@ -0,0 +1,54 @@
+import math
+import time
+import asyncio
+
+global A,An, s
+
+def leer():
+     # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+# Función que realiza la suma de dos elementos en un arreglo
+async def sum_elements(p1, p2):
+
+    global A,An
+
+    A[p2 - 1] =An[p2-1] + An[p1 - 1]
+    print(f'Suma de A[{p2}] = A[{p1}] + A[{p2}] en t={time.time() - s}')
+
+async def main():
+
+    global A,An, s
+
+    A =leer()
+    n = int(math.log2(len(A)))
+    n2 = len(A)
+    s = time.time()
+
+    for i in range(1, n + 1):
+
+        An = list(A)
+
+        print('Paso ' + str(i))
+
+        k = pow(2, i)
+        k0 = int(k / 2)
+        P = [(j-k0, j) for j in range(k0+1, n2+1)]
+
+        await asyncio.gather(*[sum_elements(*pos) for pos in P])
+
+        print(A)
+        
+    print('Resultado')
+    print(f'{A[n2 - 1]} en t={time.time() - s}')
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/concurrencia/python/Async/sumaErew.py b/concurrencia/python/Async/sumaErew.py
new file mode 100644
index 0000000..66f2964
--- /dev/null
+++ b/concurrencia/python/Async/sumaErew.py
@@ -0,0 +1,54 @@
+import math
+import time
+import asyncio
+
+global A, s
+
+
+def leer():
+     # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+# Función que realiza la suma de dos elementos en un arreglo
+async def sum_elements(p1, p2):
+
+    global A
+
+    A[p2 - 1] += A[p1 - 1]
+    print(f'Suma de A[{p2}] = A[{p1}] + A[{p2}] en t={time.time() - s}')
+
+async def main():
+
+    global A, s
+
+    A = leer()
+    n = int(math.log2(len(A)))
+    n2 = len(A)
+    s = time.time()
+
+    for i in range(1, n + 1):
+
+        print('Paso nuevo ' + str(i))
+
+        k = pow(2, i)
+        k0 = int(k / 2)
+        m = int(n2 / k)
+        P = [(j * k - k0, j * k) for j in range(1, m + 1)]
+
+        await asyncio.gather(*[sum_elements(*pos) for pos in P])
+
+        print(A)
+        
+    print('Resultado')
+    print(f'{A[n2 - 1]} en t={time.time() - s}')
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/concurrencia/python/Multiproceso/Busqueda_CRCW.py b/concurrencia/python/Multiproceso/Busqueda_CRCW.py
new file mode 100644
index 0000000..1ea9923
--- /dev/null
+++ b/concurrencia/python/Multiproceso/Busqueda_CRCW.py
@@ -0,0 +1,59 @@
+import multiprocessing as mp
+
+def leer():
+     # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+# Función que realiza la suma de dos elementos en un arreglo
+def com(A,Aord,p1, p2):
+
+    if A[p1-1]>A[p2-1]:
+        Aord[p1-1] =1
+    elif A[p1-1]==A[p2-1]:
+        pass
+    else:
+        Aord[p2-1] =1
+    print(list(Aord))
+
+def asign(A,Aord,i):
+    if Aord[i-1] == 0:
+        print(f'Minimo {list(A)[i-1]} en {i}')
+
+    
+
+if __name__ == "__main__":
+    Aux = leer()
+    n2 = len(Aux)
+
+    A = mp.Array('d', list(Aux))
+    Aord = mp.Array('d',[0]*len(Aux))
+    
+    P = [(i,j) for i in range(1, n2+1) for j in range(i+1,n2+1)]
+    processes = []
+    for pos in P:
+        p = mp.Process(target=com, args=(A,Aord, *pos))
+        processes.append(p)
+        p.start()
+
+        # Esperar a que todos los procesos terminen
+    for p in processes:
+        p.join()
+        
+
+    P = [i for i in range(1,n2+1)]
+    processes = []
+    for pos in P:
+        p = mp.Process(target=asign, args=(A,Aord,pos))
+        processes.append(p)
+        p.start()
+    
+    for p in processes:
+        p.join()
\ No newline at end of file
diff --git a/concurrencia/python/Multiproceso/MinimoEREW.py b/concurrencia/python/Multiproceso/MinimoEREW.py
new file mode 100644
index 0000000..aef111f
--- /dev/null
+++ b/concurrencia/python/Multiproceso/MinimoEREW.py
@@ -0,0 +1,54 @@
+import math
+import time
+import multiprocessing as mp
+
+global A,s
+
+def leer():
+     # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+    
+def ordenar(A,p1,p2):
+
+    if A[p2] >= A[p1]:
+        A[p2]= 1000000000
+    else:
+        A[p1]=A[p2]
+        A[p2]=1000000000
+    print(list(A))
+        
+def main():
+
+    global A,s
+    A = leer()
+    n = int(math.log2(len(A)))
+    n2 = len(A)
+    s = time.time()
+    print(A)
+    A = mp.Array('d', list(A))
+    for i in range(1, n + 1):
+        print('Paso nuevo ' + str(i))
+        k = pow(2, i)
+        k0 = int(k / 2)
+        m = int(n2 / k)
+        P = [(n2-j * k,n2+k0-j * k) for j in range(1, m + 1)]
+        print(P)
+        processes = []
+        for pos in P:
+            p = mp.Process(target=ordenar,args=(A,*pos))
+            processes.append(p)
+            p.start()
+    for p in processes:
+        p.join()
+    print(f'Mínimo es {list(A)[0]}')
+        
+if __name__ == "__main__":
+    main()
diff --git a/concurrencia/python/Multiproceso/OddEvenMerge.py b/concurrencia/python/Multiproceso/OddEvenMerge.py
new file mode 100644
index 0000000..e74c3ba
--- /dev/null
+++ b/concurrencia/python/Multiproceso/OddEvenMerge.py
@@ -0,0 +1,316 @@
+import multiprocessing as mp
+import numpy as np
+import time
+
+#Método para mp.arrays compartidos entre subprocesos
+
+def asignar_datos(data, odd, even, i):
+    if i%2==0:
+        even[i//2] = data[i]
+    else:
+        odd[i//2] = data[i]
+
+def unir_datos(data, odd, even, i):
+    data[2*i+1] = odd[i]
+    data[2*i] = even[i]
+
+def comparar_datos(data,i):
+    if data[2*i-1] > data[2*i]:
+        data[2*i-1], data[2*i] = data[2*i], data[2*i-1]
+
+#Clases de herencia de mp.Process para subprocesos de OddEvenMergeSort
+    """Cada uno de estos métodos hereda de mp.Process y sobreescribe
+    implementa for paralelo usando mp.Process para dividir, unir y comparar,
+    con un arreglo compartido entre los procesos hijos y el proceso padre (mp.array).
+    Finamente se transmiten los datos procesados al proceso padre."""
+
+class OddEvenSplit(mp.Process):
+    
+    #Constructor modificado
+    def __init__(self, data, queue):
+        #Proceso herencia
+        mp.Process.__init__(self)
+        #Atributos data, odd, even, n, queue_padre, shared_odd, shared_even
+        self.queue_padre = queue
+        self.data = data
+        #Obtener tamaño de data
+        self.n = len(data)
+        #Crear arreglos odd y even vacios
+        self.odd = np.zeros(self.n//2)
+        self.even = np.zeros(self.n//2)
+        #Crear arreglos compartidos
+        self.shared_data = mp.Array('d', self.data)
+        self.shared_odd = mp.Array('d', self.odd)
+        self.shared_even = mp.Array('d', self.even)
+        
+    def split(self):
+        processes = []
+        for i in range(self.n):
+            p = mp.Process(target=asignar_datos,
+                           args=(self.shared_data, 
+                                 self.shared_odd, 
+                                 self.shared_even, i))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+        self.odd = np.array(list(self.shared_odd))
+        self.even = np.array(list(self.shared_even))
+    
+        #Metodo run modificado
+    def run(self):
+        print(f'Split en {mp.current_process().name} \n')
+        self.split()
+        self.queue_padre.put((self.even, self.odd))
+
+
+    
+    #Constructor modificado
+    def __init__(self, data, queue):
+        #Proceso herencia
+        mp.Process.__init__(self)
+        #Atributos data, odd, even, n, queue_padre, shared_odd, shared_even
+        self.queue_padre = queue
+        self.data = data
+        #Obtener tamaño de data
+        self.n = len(data)
+        #Crear arreglos odd y even vacios
+        self.odd = np.zeros(self.n//2)
+        self.even = np.zeros(self.n//2)
+        #Crear arreglos compartidos
+        self.shared_data = mp.Array('d', self.data)
+        self.shared_odd = mp.Array('d', self.odd)
+        self.shared_even = mp.Array('d', self.even)
+        
+    def split(self):
+        processes = []
+        for i in range(self.n):
+            p = mp.Process(target=asignar_datos,
+                           args=(self.shared_data, 
+                                 self.shared_odd, 
+                                 self.shared_even, i))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+        self.odd = np.array(list(self.shared_odd))
+        self.even = np.array(list(self.shared_even))
+    
+        #Metodo run modificado
+    def run(self):
+        print(f'Split en {mp.current_process().name} \n')
+        self.split()
+        self.queue_padre.put((self.even, self.odd))
+
+class Unir(mp.Process):
+
+    #Constructor modificado
+    def __init__(self, data, odd, even, queue):
+        #Proceso herencia
+        mp.Process.__init__(self)
+        #Atributos data, odd, even, n, queue_padre, shared_odd, shared_even
+        self.queue_padre = queue
+        self.data = data
+        #Obtener tamaño de data
+        self.n = len(data)
+        self.odd = odd
+        self.even = even
+        #Crear arreglos compartidos
+        self.shared_data = mp.Array('d', self.data)
+        self.shared_odd = mp.Array('d', self.odd)
+        self.shared_even = mp.Array('d', self.even)
+
+    #Metodo run modificado
+    def run(self):
+        print(f'Unir en {mp.current_process().name} \n')
+        self.unir()
+        #Transmitir datos a padre
+        self.queue_padre.put(self.data)
+
+    def unir(self):
+        processes = []
+        for i in range(self.n//2):
+            p = mp.Process(target=unir_datos, 
+                           args=(self.shared_data, 
+                                 self.shared_odd, 
+                                 self.shared_even,i))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+        self.data = np.array(list(self.shared_data))
+
+class Comparar(mp.Process):
+
+    #Constructor modificado
+    def __init__(self, data, queue):
+        #Proceso herencia
+        mp.Process.__init__(self)
+        #Atributos data, n, queue_padre, queue_hijos
+        self.data = data
+        self.n = len(data)
+        self.queue_padre = queue
+        self.shared_data = mp.Array('d', self.data)
+
+    #Metodo run modificado
+    def run(self):
+        print(f'Comparar en {mp.current_process().name} \n')
+        self.comparar()
+        #Transmitir datos a padre
+        self.queue_padre.put(self.data)
+
+    def comparar(self):
+        processes = []
+        for i in range(1,self.n//2):
+            p = mp.Process(target=comparar_datos, 
+                           args=(self.shared_data, i))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+        self.data = np.array(list(self.shared_data))
+
+#Llamadas recursivas implementadas como llamadas al constructor en la misma clase
+"""Para la clase OddEvenMerge se implementa la llamada recursiva paralela
+    como la creación de un nuevo proceso con herencia de mp.Process
+    divide el arreglo en dos partes (odd y even) usando un proceso
+    Split, luego crea dos procesos hijos con su constructor para ordenar cada parte,
+    une las partes ordenadas con un proceso Unir y compara los elementos con un proceso
+    Comparar. Finalmente transmite los datos ordenados al padre."""
+
+class OddEvenMerge(mp.Process):
+
+    #Constructor modificdo
+    def __init__(self, data,queue):
+        #Proceso herencia
+        mp.Process.__init__(self)
+        #Atributos data, n, queue_padre, queue_hijos
+        self.data = data
+        self.n = len(data)
+        self.queue_padre = queue
+        self.queue_hijos = [mp.Queue() for i in range(2)]
+        self.queue_split = mp.Queue()
+        self.queue_unir = mp.Queue()
+        self.queue_comparar = mp.Queue()
+
+    #Metodo run modificado
+    def run(self):
+        self.oddEvenMerge()
+        #Transmitir datos a padre
+        self.queue_padre.put(self.data)
+
+    def oddEvenMerge(self):
+        if self.n==2:
+            print(f'Caso base OddEvenMerge en {mp.current_process().name} \n')
+            if self.data[0]>self.data[1]:
+                self.t = self.data[0]
+                self.data[0] = self.data[1]
+                self.data[1] = self.t
+        elif self.n > 1:
+            #Obtener odd y even
+            p1 = OddEvenSplit(self.data, self.queue_split)
+            p1.start()
+            p1.join()
+            #Recibir odd y even
+            self.even, self.odd = self.queue_split.get()
+            
+            #Crear procesos hijos odd e even
+            p2 = OddEvenMerge(self.even, 
+                              self.queue_hijos[0])
+            p2.start()
+            p3 = OddEvenMerge(self.odd, 
+                              self.queue_hijos[1])
+            p3.start()
+            p2.join()
+            p3.join()
+
+            #Obtener odd y even del queue_hijos
+            self.even = self.queue_hijos[0].get()
+            self.odd = self.queue_hijos[1].get()
+
+            #Unir odd y even
+            p4 = Unir(self.data, self.odd, self.even, 
+                      self.queue_unir)
+            p4.start()
+            p4.join()
+            #Recibir data
+            self.data = self.queue_unir.get()
+            
+            #Comparar odd y even
+            p5 = Comparar(self.data, 
+                          self.queue_comparar)
+            p5.start()
+            p5.join()
+            #Recibir data
+            self.data = self.queue_comparar.get()  
+
+"""Para la clase OddEvenMergeSort se implementa la llamada recursiva paralela
+    como la creación de un nuevo proceso con herencia de mp.Process
+    con el constructor de la clase divide el arreglo en dos partes 
+    y crea dos procesos hijos para ordenar cada parte, luego crea un 
+    proceso hijo OddEvenMerge para ordenar el arreglo completo.
+    Finalmente transmite los datos ordenados al padre."""
+
+class OddEvenMergeSort(mp.Process):
+
+    #Constructor modificdo
+    def __init__(self, data, queue):
+        #Proceso herencia
+        mp.Process.__init__(self)
+        #Atributos data, n, queue_padre, queue_hijos
+        self.data = data
+        self.queue_padre = queue
+        self.n = len(data)
+        self.queues_hijos = [mp.Queue() for i in range(3)]
+    
+    #Metodo run modificado
+    def run(self):
+        self.oddEvenMergeSort()
+        #Transmitir datos a padre
+        self.queue_padre.put(self.data)
+
+    def oddEvenMergeSort(self):
+        if self.n>1:
+            m = self.n // 2
+
+            #Crear procesos hijos
+            p1 =OddEvenMergeSort(self.data[:m], 
+                                 self.queues_hijos[0])
+            p2 =OddEvenMergeSort(self.data[m:], 
+                                 self.queues_hijos[1])
+            print(f'Llamada recursiva oddEvenMergeSort en {mp.current_process().name} \n')
+            p1.start()
+            p2.start()
+            p1.join()
+            p2.join()
+            #Recibir datos de los hijos
+            self.data[:m],self.data[m:] = self.queues_hijos[0].get() , self.queues_hijos[1].get()
+            #Crear proceso hijo OddEvenMerge
+            p3 = OddEvenMerge(self.data, 
+                              self.queues_hijos[2])
+            print(f'Llamada oddEvenMerge en oddEvenMergeSort en {mp.current_process().name} \n')
+            p3.start()
+            p3.join()
+            #Recibir datos de OddEvenMerge
+            self.data = self.queues_hijos[2].get()
+
+#Método principal
+
+def iniciar():
+    print('Odd-Even Merge Sort')
+    print('-------------------')
+    print('Ordena un arreglo aleatorio de 16 elementos -100<e<100')
+    data = np.random.randint(-100, 100, 16)
+    print('Data inicial:', data)
+    input("Presiona Enter para continuar(Click en la linea previo)...")
+    queue = mp.Queue()
+    inicio = time.time()
+    p = OddEvenMergeSort(data, queue)
+    p.start()
+    p.join()
+    fin = time.time()
+    print(f'Ejecución en {fin-inicio} segundos \n')
+    print(f'Data final: {queue.get()}')
+
+if __name__ == '__main__':
+    iniciar()
\ No newline at end of file
diff --git a/concurrencia/python/Multiproceso/Ordenamiento_CRCW.py b/concurrencia/python/Multiproceso/Ordenamiento_CRCW.py
new file mode 100644
index 0000000..9d795d5
--- /dev/null
+++ b/concurrencia/python/Multiproceso/Ordenamiento_CRCW.py
@@ -0,0 +1,60 @@
+import multiprocessing as mp
+
+def leer():
+     # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+# Función que realiza la suma de dos elementos en un arreglo
+def com(A,Aord,p1, p2):
+
+    if A[p1-1]>=A[p2-1]:
+        Aord[p1-1] +=1
+    else:
+        Aord[p2-1] +=1
+    print(list(Aord))
+
+def asign(A,A1,Aord,i):
+    A1[int(Aord[i-1])]= A[i-1]
+    print(list(A1))
+
+
+if __name__ == "__main__":
+    
+    Aux = leer()
+    n2 = len(Aux)
+
+    A = mp.Array('d', list(Aux))
+    Aord = mp.Array('d',[0]*len(Aux))
+    A1 = mp.Array('d',[0]*len(Aux))
+    
+    P = [(i,j) for i in range(1, n2+1) for j in range(i+1,n2+1)]
+    processes = []
+    for pos in P:
+        p = mp.Process(target=com, args=(A,Aord, *pos))
+        processes.append(p)
+        p.start()
+
+        # Esperar a que todos los procesos terminen
+    for p in processes:
+        p.join()
+        
+
+    P = [i for i in range(1,n2+1)]
+    processes = []
+    for pos in P:
+        p = mp.Process(target=asign, args=(A,A1,Aord,pos))
+        processes.append(p)
+        p.start()
+    
+    for p in processes:
+        p.join()
+    
+    print(f'El arreglo ordenado {list(A1)}')
diff --git a/concurrencia/python/Multiproceso/busquedaEREW.py b/concurrencia/python/Multiproceso/busquedaEREW.py
new file mode 100644
index 0000000..b57ef0f
--- /dev/null
+++ b/concurrencia/python/Multiproceso/busquedaEREW.py
@@ -0,0 +1,75 @@
+import math
+import time
+import multiprocessing as mp
+
+
+def leer():
+     # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+def llenar(Aux,p1,p2):
+    Aux[p2-1]=Aux[p1-1]
+    print(list(Aux))
+
+# Función que realiza la suma de dos elementos en un arreglo
+def cmp(A,Aux,ps,p1):
+    if(Aux[p1-1]!=A[p1-1]):
+        A[p1-1] = 1000000000
+    else:
+        ps[0] = 1
+        ps[1] = p1
+    print(list(A))
+    
+        
+def main():
+    A0 = leer()
+    n = int(math.log2(len(A0)))
+    n2 = len(A0)
+    s = time.time()
+    Aux = [0]*n2
+    Aux[0]=float(input(f"Ingrea el elemento a buscar: "))
+    print(Aux)
+
+    Aux = mp.Array('d', list(Aux))
+    A = mp.Array('d', list(A0))
+    ps = mp.Array('d', [0,0])
+
+    for i in range(1, n + 1):
+
+        print('Paso ' + str(i))
+
+        k = pow(2, i)
+        k0 = int(k / 2)
+        P = [(j, j+k0) for j in range(1, k0+1)]
+        processes = []
+        for pos in P:
+            p = mp.Process(target=llenar,args=(Aux,*pos))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+    P = [j for j in range(1, n2+1)]
+    print(P)
+    processes = []
+    for pos in P:
+        p = mp.Process(target=cmp, args=(A,Aux,ps,pos))
+        processes.append(p)
+        p.start()
+    
+    for p in processes:
+        p.join()
+    if list(ps)[0]==0:
+        print('Elemento no encontrado')
+    else:
+        print('Elemento encontrado en la posición: ',list(ps)[1])
+        
+if __name__ == "__main__":
+    main()
diff --git a/concurrencia/python/Multiproceso/matriz.py b/concurrencia/python/Multiproceso/matriz.py
new file mode 100644
index 0000000..5b0a6c7
--- /dev/null
+++ b/concurrencia/python/Multiproceso/matriz.py
@@ -0,0 +1,73 @@
+import math
+import multiprocessing as mp
+
+
+def leer_matriz(f, manager):
+
+    # Pedir al usuario el número de filas y columnas de la matriz
+    filas = f
+    # Crear una matriz vacía
+    matriz = manager.list()  # Crear una lista de multiprocessing
+
+    # Pedir al usuario que ingrese los elementos de la matriz uno por uno
+    print("Ingrese los elementos de la matriz, fila por fila:")
+    for i in range(filas):
+        fila = manager.list()  # Crear una lista de multiprocessing
+        for j in range(filas):
+            elemento = float(input(f"Elemento en la posición ({i + 1}, {j + 1}): "))
+            fila.append(elemento)
+        matriz.append(fila)
+
+    print("La matriz ingresada es:")
+    for fila in matriz:
+        print(fila)
+
+    return matriz
+
+def llenar(A,B,C,i,j,k):
+    C[i][j][k]=A[i][k]*B[k][j]
+
+def sumar(C,i,j,k,s):
+    if((2*k)%pow(2,s)==0):
+        C[i-1][j-1][2*k-1]+=C[i-1][j-1][2*k-int(pow(2,s-1))-1]
+
+
+
+def main():
+    with mp.Manager() as manager:
+        f = int(input("Ingrese el número de filas/columnas de la matriz: "))
+        A = leer_matriz(f, manager) 
+        B = leer_matriz(f, manager)
+        C = manager.list([manager.list([manager.list([0]*f) for _ in range(f)]) for _ in range(f)])
+
+        P = [(i,j,k) for i in range(0,f) for j in range(0,f) for k in range(0,f)]
+        processes = []
+        for pos in P:
+            p = mp.Process(target=llenar, args=(A,B,C, *pos))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+
+        for s in range(0,int(math.log2(f))):
+            P= [(i+1,j+1,k+1,s+1) for i in range(0,f) for j in range(0,f) for k in range(0,int(f/2))]
+            processes = []
+            for pos in P:
+                p = mp.Process(target=sumar, args=(C, *pos))
+                processes.append(p)
+                p.start()
+            for p in processes:
+                p.join()
+
+        s = ''
+        for m in range(0,f):
+            s += '['
+            for n in range (0,f):
+                s = s + str(C[m][n][f-1])+', '
+            s += ']\n'
+        print(f'\n La matriz A*B es: \n {s}')
+
+
+
+if __name__ == "__main__":
+    main()
diff --git a/concurrencia/python/Multiproceso/sumaCrew.py b/concurrencia/python/Multiproceso/sumaCrew.py
new file mode 100644
index 0000000..9f10542
--- /dev/null
+++ b/concurrencia/python/Multiproceso/sumaCrew.py
@@ -0,0 +1,52 @@
+import math
+import time
+import multiprocessing as mp
+
+def leer():
+     # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+# Función que realiza la suma de dos elementos en un arreglo
+def sum_elements(A,An,p1, p2):
+
+    A[p2 - 1] =An[p2-1] + An[p1 - 1]
+    print(f'Suma de A[{p2}] = A[{p1}] + A[{p2}] en t={time.time()}')
+
+
+if __name__ == "__main__":
+    
+    Aux =leer()
+    n = int(math.log2(len(Aux)))
+    n2 = len(Aux)
+    s = time.time()
+    An = mp.Array('d', list(Aux))
+    A =  mp.Array('d', list(Aux))
+
+
+    for i in range(1, n + 1):
+        print('Paso ' + str(i))
+        An =  mp.Array('d', list(A))
+        k = pow(2, i)
+        k0 = int(k / 2)
+        P = [(j-k0, j) for j in range(k0+1, n2+1)]
+
+        processes = []
+        for pos in P:
+            p = mp.Process(target=sum_elements, args=(A,An, *pos))
+            processes.append(p)
+            p.start()
+
+        # Esperar a que todos los procesos terminen
+        for p in processes:
+            p.join()
+        
+    print('Resultado')
+    print(f'{A[n2 - 1]} en t={time.time() - s}')
diff --git a/concurrencia/python/Multiproceso/sumaErew.py b/concurrencia/python/Multiproceso/sumaErew.py
new file mode 100644
index 0000000..cc64b0b
--- /dev/null
+++ b/concurrencia/python/Multiproceso/sumaErew.py
@@ -0,0 +1,65 @@
+
+import math
+import time
+import multiprocessing as mp
+
+global A
+
+
+def leer():
+    # Pedir al usuario el tamaño del arreglo
+    n = int(input("Ingrese el tamaño del arreglo: "))
+    # Crear un arreglo vacío
+    arreglo = []
+    # Pedir al usuario que ingrese los elementos del arreglo uno por uno
+    print("Ingrese los elementos del arreglo, uno por uno:")
+    for i in range(n):
+        elemento = float(input(f"Elemento {i + 1}: "))
+        arreglo.append(elemento)
+    return arreglo
+
+
+# Función que realiza la suma de dos elementos en un arreglo
+def sum_elements(A, p1, p2):
+    A[p2 - 1] += A[p1 - 1]
+    print(f'Suma de A[{p2}] = A[{p1}] + A[{p2}] en t={time.time()}')
+
+
+
+if __name__ == "__main__":
+    A = leer()
+    n = int(math.log2(len(A)))
+    n2 = len(A)
+    s = time.time()
+
+
+    # Crear un arreglo compartido para almacenar los resultados parciales
+    shared_A = mp.Array('d', A)
+
+    for i in range(1, n + 1):
+
+        print('Paso nuevo ' + str(i))
+        k = pow(2, i)
+        k0 = int(k / 2)
+        m = int(n2 / k)
+
+        P = [(j * k - k0, j * k) for j in range(1, m + 1)]
+
+        # Crear un proceso para cada par de elementos a sumar
+        processes = []
+        for pos in P:
+            p = mp.Process(target=sum_elements, args=(shared_A, *pos))
+            processes.append(p)
+            p.start()
+
+        # Esperar a que todos los procesos terminen
+        for p in processes:
+            p.join()
+
+        # Actualizar el arreglo original con los resultados parciales
+        A = list(shared_A)
+
+        print(A)
+
+    print('Resultado')
+    print(f'{A[n2 - 1]} en t={time.time() - s}')