Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Pascal/Turbo Pascal » Ordenar un arreglo sin perder las posiciones originales

Pascal/Turbo Pascal - Ordenar un arreglo sin perder las posiciones originales

Volver
Nuevo Tema
<<>>
 
Vista:

Ordenar un arreglo sin perder las posiciones originales

Publicado por Samuel Marcano (1 intervención) el 14/04/2019 05:47:11
Ayudaa! Necesito ordenar un arreglo pero al perder la posición original de cada índice o valor estaría perdiendo la referencia que tengo para unirlo a otro arreglo.

Es decir, tengo un arreglo de nombres y un arreglo de notas, a cada nombre le pertenece una nota (Nota[1] le pertenece a Nombre[1]) Al ordenar el vector notas (Mediante burbuja) la referencia que tenia se pierde, como hago?
Espero alguien pueda ayudarme. Lo necesito urgente!
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

Ordenar un arreglo sin perder las posiciones originales

Publicado por David (224 intervenciones) el 14/04/2019 20:44:47
Ya que usas dos arrays lo que podrías hacer sería ordenar con el mismo criterio el segundo array. a la vez que ordenas el primero.
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
sin imagen de perfil
Val: 112
Bronce
Ha mantenido su posición en Pascal/Turbo Pascal (en relación al último mes)
Gráfica de Pascal/Turbo Pascal

Ordenar un arreglo sin perder las posiciones originales

Publicado por juanba (40 intervenciones) el 21/05/2019 22:32:27
Hola. Me estoy pasando por primera vez por La web del Programador y he visto tu problema. Supongo que ya lo habrás resuelto después de cinco semanas pero por si le interesa a alguien más, aporto mis ideas.

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
program Project1;
                                       // Crear un record que combine notas y nombres

type TNotaNombre = record
  Nota: integer;
  Nombre: string;
end;
 
const NumDatos = 100;                  // Número de notas. Poner el dato real

var ListaNotas: array[1..NumDatos] of integer;
    ListaNombres: array[1..NumDatos] of string;
    ListaConjunta: array[1..NumDatos] of TNotaNombre;
    n: integer;
 
procedure BubbleSort;                  // Ordenar la lista conjunta por nota

var i, j: integer;                     // Copiado de Niklaus Wirth "Algoritmos +

    x: TNotaNombre;                    // Estructuras de Datos = Programas"

begin                                  // Capítulo 3

  for i := 2 to NumDatos do
  begin
    for j := NumDatos downto i do
      if ListaConjunta[j-1].Nota > ListaConjunta[j].Nota then
      begin
        x := ListaConjunta[j-1];
        ListaConjunta[j-1] := ListaConjunta[j];
        ListaConjunta[j] := x;
      end;
  end;
end;
 
begin
  // Obtener las dos listas (nombres y notas) ...

  for n := 1 to NumDatos do            // Crear la lista conjunta

  begin
    ListaConjunta[n].Nota := ListaNotas[n];
    ListaConjunta[n].Nombre := ListaNombres[n];
  end;
  BubbleSort;                          // Y ordenarla por nota

  // Hacer lo que sea con la lista ordenada ...

  // Por ejemplo devolver los datos ordenados a los dos arrays originales:

  for n := 1 to NumDatos do            // Devolver los datos a las listas 

  begin
    ListaNotas[n] := ListaConjunta[n].Notas;
    ListaNombres[n] := ListaConjunta[n].Nombre;
  end;
end.

No lo he verificado porque me da pereza introducir los datos, pero creo que está bien.
Al menos compila.
Otra opción, creo que es la que propone David, consiste en manipular el array de
nombres de manera sincronizada con el de notas en el procedimiento de ordenación.
Este método es más sencillo y no requiere el tipo record ni su lista:

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
32
33
34
35
program Project1;
 
const NumDatos = 100;                  // Número de notas. Poner el dato real

var ListaNotas: array[1..NumDatos] of integer;
    ListaNombres: array[1..NumDatos] of string;
    n: integer;
 
procedure BubbleSort2;                 // Ordenar la lista conjunta por nota

var i, j: integer;                     // Copiado de Niklaus Wirth "Algoritmos +

    xNota: integer;                    // Estructuras de Datos = Programas"

    xNombre: string;                   // Capítulo 3

begin
  for i := 2 to NumDatos do
  begin
    for j := NumDatos downto i do
      if ListaNotas[j-1] > ListaNotas[j] then
      begin
        xNota := ListaNotas[j-1];
        ListaNotas[j-1] := ListaNotas[j];
        ListaNotas[j] := xNota;
                                       // Si se han intercambiado las posiciones

                                       // en la lista de notas, hacer lo mismo

                                       // con la de nombres

        xNombre := ListaNombres[j-1];
        ListaNombres[j-1] := ListaNombres[j];
        ListaNombres[j] := xNombre;
      end;
  end;
end;
 
begin
  // Obtener las dos listas (nombres y notas) ...

  BubbleSort2;                         // Y ordenarlas por nota

  // Hacer lo que sea con la lista ordenada ...

end.

Este tampoco lo he verificado. Y también creo que está bien. ;-)
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