Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » ADA » quick sort en edi

ADA - quick sort en edi

Volver
Nuevo Tema
<<>>
 
Vista:

quick sort en edi

Publicado por Kajuna (1 intervención) el 30/01/2002 20:27:19
hola me gustaria saber si alguien podria explicarme como hacer el algoritmo quick sort en add.muxas gracias.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Implementación del algoritmo QuickSort

Publicado por Alejandro (155 intervenciones) el 29/06/2023 21:57:56
A continuación, te mostraré un ejemplo de implementación del algoritmo QuickSort en Ada:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
procedure Quick_Sort (Array : in out Ada.Containers.Vectors.Vector; Low, High : Integer) is
   Pivot, Temp : Integer;
   Left, Right : Integer;
begin
   if Low < High then
      Pivot := Array (Low + (High - Low) / 2);
      Left := Low;
      Right := High;
 
      while Left <= Right loop
         while Array (Left) < Pivot loop
            Left := Left + 1;
         end loop;
 
         while Array (Right) > Pivot loop
            Right := Right - 1;
         end loop;
 
         if Left <= Right then
            Temp := Array (Left);
            Array (Left) := Array (Right);
            Array (Right) := Temp;
            Left := Left + 1;
            Right := Right - 1;
         end if;
      end loop;
 
      Quick_Sort (Array, Low, Right);
      Quick_Sort (Array, Left, High);
   end if;
end Quick_Sort;

Este algoritmo de QuickSort se implementa mediante un procedimiento llamado `Quick_Sort`, que toma como parámetros un vector (`Array`), el índice más bajo (`Low`) y el índice más alto (`High`) del rango que se desea ordenar.

El procedimiento selecciona un elemento pivote, divide el vector en dos subvectores alrededor del pivote y luego recursivamente ordena los subvectores utilizando llamadas recursivas a `Quick_Sort`.

Dentro del procedimiento `Quick_Sort`, se utiliza un bucle `while` para realizar las comparaciones y el intercambio de elementos hasta que los índices `Left` y `Right` se crucen.

Es importante mencionar que este ejemplo utiliza el módulo `Ada.Containers.Vectors`, que proporciona el tipo de datos `Vector` para trabajar con vectores en Ada. Asegúrate de importar el módulo correspondiente antes de utilizar este código.

Recuerda adaptar este código según tus necesidades y asegúrate de comprender el algoritmo antes de utilizarlo en tu proyecto.

¡Espero que esta explicación y ejemplo te sean útiles!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar