fundamentos de la programación...

7

GradoenIngenieríaInformáticaGradoenIngenieríadelSoftware

GradoenIngenieríadeComputadores

LuisHernándezYáñez

FacultaddeInformáticaUniversidadComplutense

Fundamentos de la programaciónLuis Hernández Yáñez

Fundamentos de la programación: Algoritmos de ordenación

Algoritmos de ordenación 651Algoritmo de ordenación por inserción 654

Ordenación de arrays por inserción 665Algoritmo de ordenación por inserción

con intercambios 672Claves de ordenación 680Estabilidad de la ordenación 688Complejidad y eficiencia 692

Ordenaciones naturales 694Ordenación por selección directa 701Método de la burbuja 716Listas ordenadas 722Búsquedas en listas ordenadas 729Búsqueda binaria 731

Luis Hernández Yáñez

Página 651Fundamentos de la programación: Algoritmos de ordenación


Ordenacióndelistas

Mostrarlosdatosenorden,facilitarlasbúsquedas,...

Variadasformasdehacerlo(algoritmos)


array

125.40 76.95 328.80 254.62 435.00 164.29 316.05 219.99 93.45 756.62

0 1 2 3 4 5 6 7 8 9

array

76.95 93.45 125.40 164.29 219.99 254.62 316.05 328.80 435.00 756.62

0 1 2 3 4 5 6 7 8 9

Algoritmodeordenación(demenoramayor)

Algoritmodeordenación(demenoramayor)

array[i] <= array[i + 1]array[i] <= array[i + 1]


OrdenacióndelistasLosdatosdelalistadebenpodersecompararentresí

Sentidodelaordenación:

Ascendente(demenoramayor)

Descendente(demayoramenor)

Algoritmosdeordenaciónbásicos:

Ordenaciónporinserción

Ordenaciónporseleccióndirecta

Ordenaciónporelmétododelaburbuja

Losalgoritmossebasanencomparacioneseintercambios

Hayotrosalgoritmosdeordenaciónmejores





613829

AlgoritmodeordenaciónporinserciónPartimosdeunalistavacía

Vamosinsertandocadaelementoenellugarquelecorresponda

Barajadenuevecartasnumeradasdel1al9

Lascartasestándesordenadas

Ordenaremosdemenoramayor(ascendente)


475


Algoritmodeordenaciónporinserción


613829475 Listaordenada:Listaordenada:

5

ColocamoselprimerelementoenlalistavacíaColocamoselprimerelementoenlalistavacía




61382947

5 7

El7esmayorquetodosloselementosdelalista

Loinsertamosalfinal

Listaordenada:Listaordenada:




Primerelemento(5)mayorqueelnuevo(4):

Desplazamostodosunaposiciónaladerecha

Insertamoselnuevoenlaprimeraposición

6138294

5 7 754

HemosinsertadoelelementoensulugarHemosinsertadoelelementoensulugar



4 5 7



613829

9

9esmayorquetodosloselementosdelalista

Loinsertamosalfinal





61382

9 94 5 7 7542








6138

974 542 98

El9eselprimerelementomayorqueelnuevo(8):

Desplazamosdesdeesehacialaderecha

Insertamosdondeestabael9



8



613

74 542 9 987543


Segundoelemento(4)mayorqueelnuevo(3):




2 3



61

9 94 5 87 8754321








6

9 91 3 4 5 7 82 876

¡¡¡LISTAORDENADA!!!¡¡¡LISTAORDENADA!!!


El7eselprimerelementomayorqueelnuevo(6):




OrdenacióndearraysporinserciónElarraycontieneinicialmentelalistadesordenada:

Amedidaqueinsertamos:doszonasenelarray

Parteyaordenadayelementosporprocesar


20 7 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

7 14 20 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

ParteyaordenadaParteyaordenada ElementosporinsertarElementosporinsertar

SiguienteelementoainsertarenlaparteyaordenadaSiguienteelementoainsertarenlaparteyaordenada


OrdenacióndearraysporinserciónSituacióninicial:Listaordenadaconunsoloelemento(primero)

Desdeelsegundoelementodelarrayhastaelúltimo:

Localizarelprimerelementomayorenloyaordenado


20 7 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

20 7 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

Primerelementomayoroigual:índice0Primerelementomayoroigual:índice07nuevonuevo


Ordenacióndearraysporinserción...

Desplazaraladerechalosordenadosdesdeeselugar

Insertarelnuevoenlaposiciónquequedalibre


20 7 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

7nuevonuevo

7 20 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

7nuevonuevo


Implementación...int nuevo, pos;// Desde el segundo elemento hasta el último...for (int i = 1; i < N; i++) {

nuevo = lista[i];pos = 0;while ((pos < i) && !(lista[pos] > nuevo)) {

pos++;}// pos: índice del primer mayor; i si no lo hayfor (int j = i; j > pos; j‐‐) {

lista[j] = lista[j ‐ 1];}lista[pos] = nuevo;

}


const int N = 15;typedef int tLista[N];tLista lista;



20 7 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

20 20 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

20 7 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

7nuevonuevo0pospos1ii

7 20 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9



7 14 20 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

7 14 20 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

7 7 14 20 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

5 7 14 20 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9




5 7 14 20 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

5 7 14 20 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

5 7 14 20 20 32 27 12 13 15

0 1 2 3 4 5 6 7 8 9

5 7 14 14 20 32 27 12 13 15

0 1 2 3 4 5 6 7 8 9





Lainsercióndecadaelementosepuederealizarconcomparacioneseintercambios

Desdeelsegundoelementohastaelúltimo:

Desdelaposicióndelnuevoelementoainsertar:

Mientraselanteriorseamayor,intercambiar


5 7 14 20 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

5 7 14 20 14 32 27 12 13 15

0 1 2 3 4 5 6 7 8 9

5 7 14 14 20 32 27 12 13 15

0 1 2 3 4 5 6 7 8 9



7 14 20 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

7 14 20 5 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

7 14 5 20 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

7 5 14 20 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

5 7 14 20 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9


...int tmp, pos;// Desde el segundo elemento hasta el último...for (int i = 1; i < N; i++) {

pos = i;// Mientras no al principio y anterior mayor...while ((pos > 0) && (lista[pos ‐ 1] > lista[pos])) {

// Intercambiar...tmp = lista[pos];lista[pos] = lista[pos ‐ 1];lista[pos ‐ 1] = tmp;pos‐‐; // Posición anterior

}}




#include <iostream>using namespace std;#include <fstream>

const int N = 100;typedef int tArray[N];typedef struct { // Lista de longitud variable

tArray elementos;int contador;

} tLista;

int main() {tLista lista;ifstream archivo;int dato, pos, tmp;lista.contador = 0;...


insercion.cppinsercion.cpp


archivo.open("insercion.txt");if (!archivo.is_open()) {

cout << "Error de apertura de archivo!" << endl;}else {

archivo >> dato;while ((lista.contador < N) && (dato != ‐1)) {// Centinela ‐1 al final

lista.elementos[lista.contador] = dato;lista.contador++;archivo >> dato;

}archivo.close();// Si hay más de N ignoramos el restocout << "Antes de ordenar:" << endl;for (int i = 0; i < lista.contador; i++) {

cout << lista.elementos[i] << " ";}cout << endl; ...



for (int i = 1; i < lista.contador; i++) {pos = i;while ((pos > 0)&& (lista.elementos[pos‐1] > lista.elementos[pos])) {

tmp = lista.elementos[pos];lista.elementos[pos] = lista.elementos[pos ‐ 1];lista.elementos[pos ‐ 1] = tmp;pos‐‐;

}}cout << "Después de ordenar:" << endl;for (int i = 0; i < lista.contador; i++) {

cout << lista.elementos[i] << " ";}cout << endl;

}return 0;

}



Consideracióndeimplementación¿Operadorrelacionaladecuado?

lista[pos ‐ 1] ¿> o>= ? lista[pos]

Con>= serealizanintercambiosinútiles:


5 7 14 20 32 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

5 7 14 20 14 32 27 12 13 15

0 1 2 3 4 5 6 7 8 9

5 7 14 14 20 32 27 12 13 15

0 1 2 3 4 5 6 7 8 9

¡Intercambioinútil!¡Intercambioinútil!




ClavesdeordenaciónElementosquesonestructurasconvarioscampos:const int N = 15;typedef struct {

int codigo;string nombre;double sueldo;

} tDato;typedef tDato tLista[N];tLista lista;

Clavedeordenación:

Campoenelquesebasanlascomparaciones



ClavesdeordenacióntDato tmp;while ((pos > 0)

&& (lista[pos ‐ 1].nombre > lista[pos].nombre)) {tmp = lista[pos];lista[pos] = lista[pos ‐ 1];lista[pos ‐ 1] = tmp;pos‐‐;

}

Comparación:campoconcreto

Intercambio:elementoscompletos



ClavesdeordenaciónFunciónparalacomparación:bool operator>(tDato opIzq, tDato opDer) {

return (opIzq.nombre > opDer.nombre);}

tDato tmp;while ((pos > 0) && (lista[pos ‐ 1] > lista[pos])) {

tmp = lista[pos];lista[pos] = lista[pos ‐ 1];lista[pos ‐ 1] = tmp;pos‐‐;

}



Clavesdeordenación#include <iostream>#include <string>using namespace std;#include <fstream>#include <iomanip>const int N = 15;typedef struct {

int codigo;string nombre;double sueldo;

} tDato;typedef tDato tArray[N];typedef struct {

tArray datos;int cont;

} tLista;...


claves.cppclaves.cpp


void mostrar(tLista lista);bool operator>(tDato opIzq, tDato opDer);

int main() {tLista lista;ifstream archivo;lista.cont = 0;archivo.open("datos.txt");if (!archivo.is_open()) {

cout << "Error de apertura del archivo!" << endl;}else {

tDato dato;archivo >> dato.codigo;while ((lista.cont < N) && (dato.codigo != ‐1)) {

archivo >> dato.nombre >> dato.sueldo;lista.datos[lista.cont] = dato;lista.cont++;archivo >> dato.codigo;

}archivo.close(); ...



cout << "Antes de ordenar:" << endl;mostrar(lista);for (int i = 1; i < lista.cont; i++) {// Desde el segundo elemento hasta el último

int pos = i;while ((pos > 0)

&& (lista.datos[pos‐1] > lista.datos[pos])) {tDato tmp;tmp = lista.datos[pos];lista.datos[pos] = lista.datos[pos ‐ 1];lista.datos[pos ‐ 1] = tmp;pos‐‐;

}}cout << "Después de ordenar:" << endl;mostrar(lista);

}return 0;

} ...



void mostrar(tLista lista) {for (int i = 0; i < lista.cont; i++) {

cout << setw(10) << lista.datos[i].codigo<< setw(20) << lista.datos[i].nombre << setw(12) << fixed<< setprecision(2)<< lista.datos[i].sueldo << endl;

}}

bool operator>(tDato opIzq, tDato opDer) {return (opIzq.nombre > opDer.nombre);

}


Cambiaacodigo osueldo paraordenarporotroscamposCambiaacodigo osueldo paraordenarporotroscampos




AlgoritmosdeordenaciónestablesAlordenarporotraclaveunalistayaordenada,lasegundaordenaciónpreservaelordendelaprimeratDato:tresposiblesclavesdeordenación(campos)

CodigoNombreSueldo

ListaordenadaporNombre


12345 Álvarez 12000011111 Benítez 10000021112 Domínguez 9000011111 Durán 12000022222 Fernández 12000012345 Gómez 10000010000 Hernández 15000021112 Jiménez 10000011111 Pérez 9000012345 Sánchez 9000010000 Sergei 10000033333 Tarazona 12000012345 Turégano 10000011111 Urpiano 90000


OrdenamosahoraporelcampoCodigo:


10000 Sergei 10000010000 Hernández 15000011111 Urpiano 9000011111 Benítez 10000011111 Pérez 9000011111 Durán 12000012345 Sánchez 9000012345 Álvarez 12000012345 Turégano 10000012345 Gómez 10000021112 Domínguez 9000021112 Jiménez 10000022222 Fernández 12000033333 Tarazona 120000

10000 Hernández 15000010000 Sergei 10000011111 Benítez 10000011111 Durán 12000011111 Pérez 9000011111 Urpiano 9000012345 Álvarez 12000012345 Gómez 10000012345 Sánchez 9000012345 Turégano 10000021112 Domínguez 9000021112 Jiménez 10000022222 Fernández 12000033333 Tarazona 120000

Noestable:Losnombresnomantienensusposicionesrelativas

Noestable:Losnombresnomantienensusposicionesrelativas

Estable:Losnombresmantienensusposicionesrelativas

Estable:Losnombresmantienensusposicionesrelativas


OrdenaciónporinserciónEstablesiemprequeutilicemos< o> Con<= o>= noesestable

Ordenamosporsueldo:

Aigualsueldo,ordenadoporcódigosyaigualcódigo,pornombres


10000 Hernández 15000010000 Sergei 10000011111 Benítez 10000011111 Durán 12000011111 Pérez 9000011111 Urpiano 9000012345 Álvarez 12000012345 Gómez 10000012345 Sánchez 9000012345 Turégano 10000021112 Domínguez 9000021112 Jiménez 10000022222 Fernández 12000033333 Tarazona 120000

11111 Pérez 9000011111 Urpiano 9000012345 Sánchez 9000021112 Domínguez 9000010000 Sergei 10000011111 Benítez 10000012345 Gómez 10000012345 Turégano 10000021112 Jiménez 10000011111 Durán 12000012345 Álvarez 12000022222 Fernández 12000033333 Tarazona 12000010000 Hernández 150000




Casosdeestudioparalosalgoritmosdeordenación Listainicialmenteordenada

Listainicialmenteordenadaalrevés

Listacondisposicióninicialaleatoria

¿Trabajamenos,másoiguallaordenaciónencadacaso?


5 7 12 13 14 14 15 20 27 32

0 1 2 3 4 5 6 7 8 9

32 27 20 15 14 14 13 12 7 5

0 1 2 3 4 5 6 7 8 9

13 20 7 14 12 32 27 14 5 15

0 1 2 3 4 5 6 7 8 9


OrdenacionesnaturalesSielalgoritmotrabajamenoscuantomásordenada estáinicialmentelalista,sedicequelaordenaciónesnatural

Ordenaciónporinserciónconlalistainicialmenteordenada:

Versiónquebuscaellugarprimeroyluegodesplaza:Nohaydesplazamientos;mismonúmerodecomparacionesComportamientononatural

Versiónconintercambios:Trabajamuchomenos;bastaunacomparacióncadavezComportamientonatural



Eleccióndeunalgoritmodeordenación¿Cómodebuenoescadaalgoritmo?

¿Cuántotardaencomparaciónconotrosalgoritmos?

Algoritmosmáseficientes:losdemenorcomplejidad

TardanmenosenrealizarlamismatareaComparamosenordendecomplejidad:O()

Enfuncióndeladimensióndelalistaaordenar:N

O() = f (N)

Operacionesquerealizaelalgoritmodeordenación:

Comparaciones

Intercambios

Asumimosquetardanuntiemposimilar



CálculodelacomplejidadOrdenaciónporinserción(conintercambios):...for (int i = 1; i < N; i++) {int pos = i;while ((pos > 0) && (lista[pos ‐ 1] > lista[pos])) {

int tmp;tmp = lista[pos];lista[pos] = lista[pos ‐ 1];lista[pos ‐ 1] = tmp;pos‐‐;

}}

Intercambiosycomparaciones:Tantoscomociclosrealicenloscorrespondientesbucles


ComparaciónComparación

IntercambioIntercambio


Cálculodelacomplejidad

...for (int i = 1; i < N; i++) {int pos = i;while ((pos > 0) && (lista[pos ‐ 1] > lista[pos])) {

int tmp;tmp = lista[pos];lista[pos] = lista[pos ‐ 1];lista[pos ‐ 1] = tmp;pos‐‐;

}}

Casoenelqueelwhile seejecutamás:casopeorCasoenelqueseejecutamenos:casomejor


N‐ 1ciclosN‐ 1ciclos

NºvariabledeciclosNºvariabledeciclos


Cálculodelacomplejidad Casomejor:listainicialmenteordenada

Laprimeracomparaciónfalla:ningúnintercambio(N‐ 1)*(1comparación+0intercambios)=N‐ 1 O(N)

Casopeor:listainicialmenteordenadaalrevésParacadapos,entrei y1:1comparacióny1intercambio1+2+3+4+...+(N‐ 1)((N‐ 1)+1)x (N‐ 1)/2N*(N‐ 1)/2(N2 ‐ N)/2 O(N2)

NotaciónOgrande:ordendecomplejidadenbaseaNEltérminoenNquemásrápidamentecrecealcrecerNEnelcasopeor,N2 crecemásrápidoqueN O(N2)(Ignoramoslasconstantes,como2)



Ordenaciónporinserción(conintercambios) Casomejor:O(N)

Casopeor:O(N2)

Casomedio(distribuciónaleatoriadeloselementos):O(N2)

Hayalgoritmosdeordenaciónmejores



Órdenesdecomplejidad

O(logN) <O(N) <O(NlogN) <O(N2) <O(N3) ...

N log2 N N2

‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐1 0 12 1 44 2 168 3 6416 4 25632 5 102464 6 4096128 7 16384256 8 65536...





Algoritmodeordenaciónporseleccióndirecta


SeleccionarelsiguienteelementomenordelosquequedenSeleccionarelsiguienteelementomenordelosquequeden

613829475


Listadesordenada:Listadesordenada:




6

1

3829475






6

1

38

2

9475








6

1 3

8

2

9475







6

1 3

8

2

9

4

75







6

1 3

8

2

9

4

7

5Listaordenada:Listaordenada:






61 3

8

2

9

4

7

5Listaordenada:Listaordenada:






61 3

8

2

9

4 75Listaordenada:Listaordenada:






61 3 82

9

4 75Listaordenada:Listaordenada:






61 3 82 94 75Listaordenada:Listaordenada:


¡¡¡LISTAORDENADA!!!¡¡¡LISTAORDENADA!!!



Ordenacióndeunarrayporseleccióndirecta

Desdeelprimerelemento(i =0)hastaelpenúltimo(N‐2):

Menorelemento(enm)entrei +1yelúltimo(N‐1)

Intercambiarloselementoseni ym sinosonelmismo


20 7 14 32 5 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

mmii

5 7 14 32 20 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

mmii

SólointercambiamossinoeslamismaposiciónSólointercambiamossinoeslamismaposición


Ordenacióndeunarrayporseleccióndirecta


5 7 14 32 20 14 27 12 13 15

0 1 2 3 4 5 6 7 8 9

mmii

5 7 12 32 20 14 27 14 13 15

0 1 2 3 4 5 6 7 8 9

mmii

5 7 12 13 20 14 27 14 32 15

0 1 2 3 4 5 6 7 8 9

mmii


Implementación

// Desde el primer elemento hasta el penúltimo...for (int i = 0; i < N ‐ 1; i++) {

int menor = i;// Desde i + 1 hasta el final...for (int j = i + 1; j < N; j++) {

if (lista[j] < lista[menor]) {menor = j;

}}if (menor > i) {

int tmp;tmp = lista[i];lista[i] = lista[menor];lista[menor] = tmp;

}}


seleccion.cppseleccion.cpp



Complejidaddelaordenaciónporseleccióndirecta¿Cuántascomparacionesserealizan?

Bucleexterno:N‐ 1ciclos

Tantascomparacionescomoelementosquedenenlalista:

(N‐ 1)+(N‐ 2)+(N‐ 3)+...+3+2+1=Nx (N‐ 1)/2=(N2 ‐ N)/2 O(N2)

Mismonúmerodecomparacionesentodosloscasos

Complejidad:O(N2) Igualqueelmétododeinserción

Algomejor(menosintercambios;unoencadapaso)

Noesestable:intercambios“alargadistancia”Nosegarantizaquesemantengaelmismoordenrelativooriginal

Comportamientononatural(trabajasiemprelomismo)





AlgoritmodeordenaciónporelmétododelaburbujaVariacióndelmétododeseleccióndirecta

Elelementomenorvaascendiendo hastaalcanzarsuposición


6

3

1

9

4

6

3

1

9

4

6

1

3

9

4

6

4

3

9

1

6

4

3

1

9



12 32 14 5 14 7

0 1 2 3 4 5

12 32 14 5 7 14

0 1 2 3 4 5

12 32 14 5 7 14

0 1 2 3 4 5

12 32 5 14 7 14

0 1 2 3 4 5

12 5 32 14 7 14

0 1 2 3 4 5

5 12 32 14 7 14

0 1 2 3 4 5


OrdenacióndeunarrayporelmétododelaburbujaDesdeelprimero(i =0),hastaelpenúltimo(N‐ 2):Desdeelúltimo(j =N– 1),hastai +1:Sielementoenj <elementoenj ‐ 1,intercambiarlos

...int tmp;// Del primero al penúltimo...for (int i = 0; i < N ‐ 1; i++) {

// Desde el último hasta el siguiente a i...for (int j = N ‐ 1; j > i; j‐‐) {

if (lista[j] < lista[j ‐ 1]) {tmp = lista[j];lista[j] = lista[j ‐ 1];lista[j ‐ 1] = tmp;

}}

}


burbuja.cppburbuja.cpp



AlgoritmodeordenaciónporelmétododelaburbujaComplejidad:O(N2)

Comportamientononatural

Estable(mantieneelordenrelativo)

Mejora:

Sienunpasodelbucleexteriornohahabidointercambios:

Lalistayaestáordenada(noesnecesarioseguir)

14 14 14 12

16 16 12 14

35 12 16 16

12 35 35 35

50 50 50 50


Lalistayaestáordenada

Nohacefaltaseguir


bool inter = true;int i = 0;// Desde el 1º hasta el penúltimo si hay intercambios...while ((i < N ‐ 1) && inter) {

inter = false;// Desde el último hasta el siguiente a i...for (int j = N ‐ 1; j > i; j‐‐) {

if (lista[j] < lista[j ‐ 1]) {int tmp;tmp = lista[j];lista[j] = lista[j ‐ 1];lista[j ‐ 1] = tmp;inter = true;

}}if (inter) {

i++;}

}


burbuja2.cppburbuja2.cpp

Estavariaciónsítieneuncomportamientonatural




GestióndelistasordenadasCasitodaslastareasserealizanigualqueenlistassinorden

Operacionesquetenganencuentaelorden:

Insercióndeunnuevoelemento:debeseguirenorden

Búsquedasmáseficientes

¿Ylacargadesdearchivo?

Siloselementosseguardaronenorden:seleeigual

Siloselementosnoestánordenadosenelarchivo:insertar



Declaraciones:Igualesqueparalistassinordenconst int N = 20;

typedef struct {int codigo;string nombre;double sueldo;

} tRegistro;

typedef tRegistro tArray[N];

typedef struct {tArray registros;int cont;

} tLista;


lista.cpplista.cpp


Subprogramas:Mismadeclaraciónqueparalistassinordenvoid mostrarDato(int pos, tRegistro registro);

void mostrar(tLista lista);

bool operator>(tRegistro opIzq, tRegistro opDer);

bool operator<(tRegistro opIzq, tRegistro opDer);

tRegistro nuevo();

void insertar(tLista &lista, tRegistro registro, bool &ok);

void eliminar(tLista &lista, int pos, bool &ok); // pos = 1..N

int buscar(tLista lista, string nombre);

void cargar(tLista &lista, bool &ok);

void guardar(tLista lista);



Nuevasimplementaciones:

Operadoresrelacionales

Inserción(mantenerelorden)

Búsqueda(máseficiente)

Seguardalalistaenorden,porloquecargar() nocambia

bool operator>(tRegistro opIzq, tRegistro opDer) {

return opIzq.nombre > opDer.nombre;

}

bool operator<(tRegistro opIzq, tRegistro opDer) {

return opIzq.nombre < opDer.nombre;

}



void insertar(tLista &lista, tRegistro registro, bool &ok) {ok = true;if (lista.cont == N) {

ok = false; // lista llena}else {

int i = 0;while ((i < lista.cont) && (lista.registros[i] < registro)) {

i++;}// Insertamos en la posición i (primer mayor o igual)for (int j = lista.cont; j > i; j‐‐) {// Desplazamos una posición a la derecha

lista.registros[j] = lista.registros[j ‐ 1];}lista.registros[i] = registro;lista.cont++;

}}





BúsquedadeunelementoenunasecuenciaNoordenada:recorremoshastaencontrarlooalfinal

Ordenada:recorremoshastaencontrarloomayor /alfinal

Buscamosel36:alllegaralfinalsabemosquenoestá

Buscamosel17:alllegaral20yasabemosquenoestá

Condicionesdeterminación:

Sellegaalfinal

Seencuentraelelementobuscado

Seencuentraunomayor

Mientrasnoalfinalyelvalorseamenorqueelbuscado


5 7 12 13 14 14 15 20 27 32

0 1 2 3 4 5 6 7 8 9


int buscado;cout << "Valor a buscar: ";cin >> buscado;int i = 0;while ((i < N) && (lista[i] < buscado)) {

i++;}// Ahora, o estamos al final o lista[i] >= buscadoif (i == N) { // Al final: no se ha encontrado

cout << "No encontrado!" << endl;}else if (lista[i] == buscado) { // Encontrado!

cout << "Encontrado en posición " << i + 1 << endl;}else { // Hemos encontrado uno mayor

cout << "No encontrado!" << endl;}


Complejidad:O(N)





Búsquedamuchomásrápidaqueaprovechalaordenación

Compararconelvalorqueestéenelmediodelalista:Sieselquesebusca,terminarSino,siesmayor,buscarenlaprimeramitaddelalistaSino,siesmenor,buscarenlasegundamitaddelalistaRepetirhastaencontrarloonoquedesublistadondebuscar


5 7 12 14 14 15 18 20 27 32

0 1 2 3 4 5 6 7 8 9

5 7 12 14 14 15 18 20 27 32

0 1 2 3 4 5 6 7 8 9

Buscamosel12

5 7 12 14 14 15 18 20 27 32

0 1 2 3 4 5 6 7 8 9

ElementomitadElementomitad


Vamosbuscandoensublistascadavezmáspequeñas(mitades)

Delimitamoselsegmentodelalistadondebuscar

Inicialmentetenemostodalalista:

Índicedelelementoenlamitad:mitad = (ini + fin) / 2

Sinoseencuentra,¿dóndeseguirbuscando?Buscado<elementoenlamitad:fin = mitad ‐ 1

Buscado>elementoenlamitad:ini = mitad + 1

Siini >fin,noquedadóndebuscar


5 7 12 14 14 15 18 20 27 32

0 1 2 3 4 5 6 7 8 9

iniini finfinmitadmitad


12 < lista[mitad] fin = mitad – 1

12 > lista[mitad] ini = mitad + 1


5 7 12 14 14 15 18 20 27 32

0 1 2 3 4 5 6 7 8 9


Buscamosel12

5 7 12 14 14 15 18 20 27 32

0 1 2 3 4 5 6 7 8 9


5 7 12 14 14 15 18 20 27 32

0 1 2 3 4 5 6 7 8 9

iniini finfin

mitadmitad ¡Encontrado!


Sielelementonoestá,nosquedamossinsublista:ini > fin

13 > lista[mitad] ini = mitad + 1

13 < lista[mitad] fin = mitad – 1 2

¡¡¡ini > fin !!! Nohaydóndeseguirbuscando Noestá


5 7 12 14 14 15 18 20 27 32

0 1 2 3 4 5 6 7 8 9

mitadmitadiniini finfin

5 7 12 14 14 15 18 20 27 32

0 1 2 3 4 5 6 7 8 9

iniinifinfin

mitadmitad

Parael13:


Implementaciónint buscado;cout << "Valor a buscar: ";cin >> buscado;int ini = 0, fin = N – 1, mitad;bool encontrado = false;while ((ini <= fin) && !encontrado) {

mitad = (ini + fin) / 2; // División enteraif (buscado == lista[mitad]) {

encontrado = true;}else if (buscado < lista[mitad]) {

fin = mitad ‐ 1;}else {

ini = mitad + 1;}

} // Si se ha encontrado, está en [mitad]




#include <iostream>using namespace std;#include <fstream>

const int N = 100;typedef int tArray[N];typedef struct {

tArray elementos;int cont;

} tLista;

int buscar(tLista lista, int buscado);

int main() {tLista lista;ifstream archivo;int dato;lista.cont = 0;archivo.open("ordenados.txt"); // Existe y es correctoarchivo >> dato;...


binaria.cppbinaria.cpp


while ((lista.cont < N) && (dato != ‐1)) {lista.elementos[lista.cont] = dato;lista.cont++;archivo >> dato;

}archivo.close();for (int i = 0; i < lista.cont; i++) {

cout << lista.elementos[i] << " ";}cout << endl;int buscado, pos;cout << "Valor a buscar: ";cin >> buscado;pos = buscar(lista, buscado);if (pos != ‐1) {

cout << "Encontrado en la posición " << pos + 1 << endl;}else {

cout << "No encontrado!" << endl;} return 0;

} ...



int buscar(tLista lista, int buscado) {int pos = ‐1, ini = 0, fin = lista.cont ‐ 1, mitad;bool encontrado = false;while ((ini <= fin) && !encontrado) {

mitad = (ini + fin) / 2; // División enteraif (buscado == lista.elementos[mitad]) {

encontrado = true;}else if (buscado < lista.elementos[mitad]) {

fin = mitad ‐ 1;}else {

ini = mitad + 1;}

}if (encontrado) {

pos = mitad;}return pos;

}



Complejidad¿Quéordendecomplejidadtienelabúsquedabinaria?

Casopeor:

Noestáoseencuentraenunasublistade1elemento

Nºdecomparaciones=Nºdemitadesquepodemoshacer

N/2,N/4,N/8,N/16,...,8,4,2,1

1,2,4,8,...,N/16,N/8,N/4,N/2SihacemosqueNseaiguala2k:

20,21,22,23,...,2k‐4,2k‐3,2k‐2,2k‐1

Nºdeelementosdeesaserie:k

Nºdecomparaciones=k N=2k k=log2 N

Complejidad:O(log2 N) MuchomásrápidaqueO(N)



LicenciaCC(Creative Commons)Estetipodelicenciasofrecenalgunosderechosaterceraspersonasbajociertascondiciones.

Estedocumentotieneestablecidaslassiguientes:

Pulsaenlaimagendearribaaladerechaparasabermás.

Fundamentos de la programación: Algoritmos de ordenación Página 741

Reconocimiento(Attribution):Encualquierexplotacióndelaobraautorizadaporlalicenciaharáfaltareconocerlaautoría.

Nocomercial(Noncommercial):Laexplotacióndelaobraquedalimitadaausosnocomerciales.

Compartirigual(Sharealike):Laexplotaciónautorizadaincluyelacreacióndeobrasderivadassiemprequemantenganlamismalicenciaalserdivulgadas.

7A

GradoenIngenieríaInformáticaGradoenIngenieríadelSoftware

GradoenIngenieríadeComputadores

LuisHernándezYáñez

FacultaddeInformáticaUniversidadComplutense

Fundamentos de la programaciónLuis Hernández Yáñez

Fundamentos de la programación: Algoritmos de ordenación (Anexo)

Ordenación por intercambio 744Mezcla de dos listas ordenadas 747


Página 744Fundamentos de la programación: Algoritmos de ordenación (Anexo)


AlgoritmodeordenaciónporintercambioVariacióndelmétododeseleccióndirecta

Seintercambiaelelementodelaposiciónquesetrataencadamomentosiemprequeseencuentraunoqueesmenor:


14 7 12 32 20 14 27 5 13 150 1 2 3 4 5 6 7 8 9

7 14 12 32 20 14 27 5 13 150 1 2 3 4 5 6 7 8 9

5 14 12 32 20 14 27 7 13 150 1 2 3 4 5 6 7 8 9


const int N = 10;typedef int tLista[N];tLista lista;...for (int i = 0; i < N ‐ 1; i++) {// Desde el primer elemento hasta el penúltimo

for (int j = i + 1; j < N; j++) {// Desde i+1 hasta el final

if (lista[j] < lista[i]) {int tmp;tmp = lista[i];lista[i] = lista[j];lista[j] = tmp;

}

}

}

Igualnúmerodecomparaciones,muchosmásintercambiosNoesestable


intercambio.cppintercambio.cppLuis Hernández Yáñez



Mezcladedoslistasordenadasenarraysconst int N = 100;typedef struct {int elementos[N];int cont;

} tLista;

Uníndiceparacadalista,inicializadosa0(principiodelaslistas)

Mientrasquenolleguemosalfinaldealgunadelasdoslistas:

Elegimoselelementomenordelosquetienenlosíndices

Locopiamosenlalistaresultadoyavanzamossuíndiceunaposición

Copiamosenlalistaresultadolosquequedenenlalistanoacabada



void mezcla(tLista lista1, tLista lista2, tLista &listaM) {int pos1 = 0, pos2 = 0;listaM.cont = 0;

while ((pos1 < lista1.cont) && (pos2 < lista2.cont)&& (listaM.cont < N)) {

if (lista1.elementos[pos1] < lista2.elementos[pos2]) {listaM.elementos[listaM.cont] = lista1.elementos[pos1];pos1++;

}else {

listaM.elementos[listaM.cont] = lista2.elementos[pos2];pos2++;

}listaM.cont++;

}...



// Pueden quedar datos en alguna de las listasif (pos1 < lista1.cont) {

while ((pos1 < lista1.cont) && (listaM.cont < N)) {listaM.elementos[listaM.cont] = lista1.elementos[pos1];pos1++;listaM.cont++;

}}else { // pos2 < lista2.cont

while ((pos2 < lista2.cont) && (listaM.cont < N)) {listaM.elementos[listaM.cont] = lista2.elementos[pos2];pos2++;listaM.cont++;

}}

}


mezcla1.cppmezcla1.cppLuis Hernández Yáñez

Mezcladedoslistasordenadasenarchivosvoid mezcla(string nombre1, string nombre2, string nombreM) {// Mezcla las secuencias en los archivos nombnre1 y nombre2// generando la secuencia mezclada en el archivo nombreM

ifstream archivo1, archivo2;ofstream mezcla;int dato1, dato2;

// Los archivos existen y son correctosarchivo1.open(nombre1.c_str());archivo2.open(nombre2.c_str());mezcla.open(nombreM.c_str());archivo1 >> dato1;archivo2 >> dato2;while ((dato1 != ‐1) && (dato2 != ‐1)) {// Mientras quede algo en ambos archivos

...



if (dato1 < dato2) {mezcla << dato1 << endl;archivo1 >> dato1;

} else {mezcla << dato2 << endl;archivo2 >> dato2;

}} // Uno de los dos archivos se ha acabadoif (dato1 != ‐1) { // Quedan en el primer archivo

while (dato1 != ‐1) {mezcla << dato1 << endl;archivo1 >> dato1;

}}else { // Quedan en el segundo archivo

while (dato2 != ‐1) {mezcla << dato2 << endl;archivo2 >> dato2;

}}...



archivo2.close();archivo1.close();mezcla << ‐1 << endl;mezcla.close();

}


mezcla2.cppmezcla2.cpp


LicenciaCC(Creative Commons)Estetipodelicenciasofrecenalgunosderechosaterceraspersonasbajociertascondiciones.

Estedocumentotieneestablecidaslassiguientes:

Pulsaenlaimagendearribaaladerechaparasabermás.

Fundamentos de la programación: Algoritmos de ordenación (Anexo) Página 754

Reconocimiento(Attribution):Encualquierexplotacióndelaobraautorizadaporlalicenciaharáfaltareconocerlaautoría.

Nocomercial(Noncommercial):Laexplotacióndelaobraquedalimitadaausosnocomerciales.

Compartirigual(Sharealike):Laexplotaciónautorizadaincluyelacreacióndeobrasderivadassiemprequemantenganlamismalicenciaalserdivulgadas.

Fundamentos de la programación Ejercicios del Tema 7 — Pág. 1

Facultad de Informática – Universidad Complutense

Fundamentos de la programación Curso 2013–2014

HojadeejerciciosdelTema7

1. Utilizando las estructuras de datos definidas en el ejercicio 5 de la hoja deejerciciosdelTema5(empleadosdeunaempresa),ordenalalistasegúneltipode contratación de los empleados (Fijo, En prácticas, Eventual o Becario)utilizandolostresalgoritmosdeordenaciónvistosenclase:

a) Ordenaciónporinserción

b) Ordenaciónporseleccióndirecta

c) Métododelaburbuja

2. Enunarchivode textoinventario.txt seguarda informaciónacercade losproductos existentes en un almacén. Para cada producto se guardan lossiguientesdatos:

Códigodelproducto(enteropositivo)

Nombredelproducto

Númerodeunidades(entero)

Precioporunidad(real)

Elarchivoestáordenadoporordencrecientedelcódigodeproductoyterminaconun‐1comocódigo.

Se dispone además de otro archivo, modificaciones.txt, en el que seguardanlasmodificacionesenelnúmerodeartículosquesehanproducidoalolargo de todo un día. Cada componente del archivo modificaciones.txtconstadelossiguientescampos:

Códigodelproducto(enteropositivo)

Códigodeoperación:venta(V),compra(C),odevolución(D)

Númerodeunidades(entero)

El archivo modificaciones.txt está organizado secuencialmente y no seencuentra ordenado de ninguna manera especial. Puede haber variasmodificaciones relativas al mismo producto. Es decir, el producto de código2331 puede tener asociadas, por ejemplo, tres componentes del archivomodificaciones.txt: la primera puede tratarse de la devolución de 100unidades,lasegundadeladevoluciónde50unidadesylaterceradelaventade550unidades.Terminaconun‐1comocódigo.


Sepide:

a) Efectuarlasdeclaracionesnecesarias.

b) Implementarunsubprogramaquecoloquelainformacióndelarchivoinventario.txtenlasestructurasdedatoscorrespondientes.

c) Implementarunsubprogramaqueguardeenunarchivoinventario2.txtlainformacióncontenidaenlalistadelinventario.

d) Implementarunsubprogramaquedadouncódigodeproductodevuelvasuposiciónenlalistadelinventario.Deberealizarunabúsquedabinaria.

e) Implementarunsubprogramaqueactualicelalistadelinventarioprocesandoloscambiosdelarchivomodificaciones.txt(lasventasdisminuyenelnúmerodeunidadesylascomprasydevolucionesloaumentan).

3. Se quiere implementar una aplicación para gestionar la información de lasobraspictóricascatalogadasenelmuseodelPradodeMadrid.Elnúmerototalde obras del museo no puede superar un cierto valor máximo N, siendo elnúmerodeobrasexistentesencadamomentovariable.La informaciónquesequierealmacenarparacadaobraconsisteen:

Númerodecatálogo(enteropositivo)

Títulodelaobra(cadena)

Nombredelpintor(cadena)

Escueladelpintor(Española,Flamenca,Italiana,Francesa,Holandesa,AlemanaoInglesa).

Lasobrassemantendránordenadasporelnúmerodecatálogo.

Sepide:

a) Redactarlasdeclaracionesadecuadas.

b) Implementarunsubprogramaquecargueenlalistalainformacióndeunarchivodetextomuseo.txtsobreobraspictóricasordenadaspornúmerodecatálogo.Paracadaobra,elarchivocontienecuatrolíneas,queindican,enesteorden,elnúmerodecatálogo,eltítulo,elnombredelpintorylaescuela.Terminacon‐1comonúmerodecatálogo.

c) Implementarunsubprogramaque,dadosunalistadeobrasyelnúmerodecatálogodeunaobra,eliminedelalistalaobracondichonúmerodecatálogo,siesqueexiste,ydevuelvaunvalorqueindiquesilaoperaciónhatenidoéxito.Suponerquelalistadeobrasestáordenadaenordencrecienteporelnúmerodecatálogoyquenoexistennúmerosdecatálogorepetidos.Silaoperacióntieneéxito(sesuprimelaobra):Nodebenquedar“huecos”enlalista.


4. [Controldeabrilde2012]Sepideconstruirunprogramaqueproceseelstockdeuna tienda. El stock es una lista de longitud variable de productos (máximo100).Paracadaproductosemantienelasiguienteinformación:

Código(enteropositivo)

Nombre(unasolapalabra)

Precio(real)

Unidades(enteropositivo)

El programa comenzará leyendo la información del stock de un archivostock.txt. El archivo contiene cuatro líneas por producto (código, nombre,precio y unidades). Termina con un ‐1 como código.Hay que comprobar queexistaysihaymásdelmáximodeproductos,seignoraránlosadicionales.

A continuación, el programa mostrará la lista de productos y calculará ymostraráelactivototaldelatienda(elactivodeunproductoessuprecioporsunúmero de unidades; el activo total es la suma de los activos de todos losproductos).Seguiráordenandolalistapornombresdeproductosyfinalmentevolveráamostrarlalista.

Lalistasemostraráconunformatocomoelsiguiente:

123 TV_PLASMA_32" 457.95 € 4 unidades

4265 TV_LED_38" 379.95 € 12 unidades

43256 DVD_GRABADOR_250_Gb 255.00 € 8 unidades

672 TABLET_10"_HD_WiFi_3G 428.50 € 5 unidades

(Anchurade6yajusteaderechaparaelcódigo,anchurade30yajusteaizquierdaparaelnombre,anchura de 8 y dos decimales para el precio, anchura de 3 y ajuste a derecha para el número deunidades.)

Se desarrollarán, al menos, los siguientes subprogramas: leer stock, activo(activototaldelatienda),ordenar,mostrarproducto(líneaconlainformacióndelproductoproporcionado)ymostrarstock.

5. [Controldeabrilde2013]Sepideconstruirunprogramaquemuestreporordendefechalosalquileresdeunaagenciadealquilerdecoches.Sedisponededosarchivos,uno(coches.txt)conlainformacióndecódigos(enteros)ynombres(cadenas)deloscochesdelosquesedispone.Lainformaciónenelarchivoestáordenadaporcódigosyterminacon‐1comocódigo:

1325 Seat León 1548 Volkswagen Golf ... ‐1 El otro archivo (rent.txt) contiene (sin ningún orden) la relación dealquileres que se han contratado (código del coche, fecha en formatoAA/MM/DDydíasquesehaalquilado).Terminaconun‐1comocódigo:


7377 13/03/19 1 2176 13/02/11 7 6664 13/03/17 3 3349 13/01/21 1 ... ‐1 El programa deberá empezar cargando la información de cada archivo ensendaslistas:unalistadecoches(máximo20)yunalistadealquileres(máximo100). La lista de coches quedará ordenada por orden de códigos (como en elarchivo).

Una vez leídas las listas ordenará la lista de alquileres por fechas. Terminarámostrandolainformaciónsobrelosalquileres(fecha,modeloydíasalquilado):

13/01/17 Volkswagen Golf 3 día(s) 13/01/21 Opel Zafira 1 día(s) 13/01/31 Opel Vivaro 3 día(s) ... 13/02/26 Volkswagen Passat 3 día(s) 13/02/27 ERROR: ¡¡¡Modelo inexistente!!! ...

Elprogramadeberáhacerusodelossiguientessubprogramas:

leerModelos():cargalainformacióndelarchivocoches.txtenlalistadecoches;devuelvetruesisehapodidoabrirelarchivoyfalseencasocontrario. La lista de coches sólo contendrá la información de estearchivo.

leerAlquileres(): carga la información del archivo rent.txt en lalistadealquileres;devuelvetruesisehapodidoabrirelarchivoyfalseencasocontrario.Lalistadealquileressólocontendrálainformacióndeestearchivo.

ordenar(): ordena la lista de alquileres por orden de fecha (menor amayor).

buscar(): dada la lista de coches y un código, devuelve la posición(índice) del elemento de la lista de coches con ese código; si no seencuentra el código devuelve ‐1. Debe implementarse como búsquedabinaria.

mostrar():dadasambaslistas,muestralarelacióndealquileresconelformato mostrado arriba; si no se encuentra un código de coche senotificaráelerror.

fundamentos de la programación...

Documents