Guía didáctica

Estructuras
de Datos en
Sistemas
 Introducción
Un algoritmo es una secuencia finita de operaciones, organizadas
para realizar una tarea determinada. Las estructuras de datos son
la forma en que se organizan los datos para ser usados. Puede ser
una colección de variables, posiblemente de diferentes tipos de
datos, conectadas de un modo determinado.

Una estructura de datos bien organizada debe permitir realizar un

conjunto de acciones sobre los datos de tal forma de minimizar el uso
de los recursos y el tiempo empleado para efectuar la operación. La
información que se procesa en la computadora es un conjunto de
datos, que pueden ser simples o estructurados. Los datos simples
son aquellos que ocupan sólo una localidad de memoria, mientras
que los estructurados son un conjunto de casillas de memoria a las
cuales hacemos referencia mediante un identificador único.

Debido a que por lo general tenemos que tratar con conjuntos de

datos y no con datos simples (enteros, reales, booleanos, etc.) que
por sí solos no nos dicen nada, ni nos sirven de mucho, es necesario
tratar con estructuras de datos adecuadas a cada necesidad.

Las estructuras de datos son una colección de datos

cuya organización se caracteriza por las funciones de acceso que se
usan para almacenar y acceder a elementos individuales de datos.
Una estructura de datos se caracteriza por lo siguiente:

 Pueden descomponerse en los elementos que la forman.

 La manera en que se colocan los elementos dentro de la estructura
afectará la forma en que se realicen los accesos a cada elemento.
 La colocación de los elementos y la manera en que se accede a ellos
puede ser encapsulada.
 ¿Qué es una estructura de datos?
Cuando hablamos de programación, la estructura de datos
está representada por una forma determinada que tenemos
de organizar los datos de un equipo informático para que
podamos utilizarlos de la manera más efectiva posible.

Dependiendo del tipo de aplicación o recurso que

vayamos a usar requeriremos una estructura de datos
independiente y distinta a las demás, dado que cada una
encaja en el contexto de forma determinada y con una serie
de objetivos. Con estas estructuras tenemos la posibilidad de
administrar todo tipo de datos sin ningún tipo de obstáculo,
algo que en la actualidad se usa en la red para poder llevar a
cabo, por ejemplo, los sistemas de indexado de contenidos.
Y también juegan un papel clave en la creación de los
mejores algoritmos, así como en su uso con lenguajes de
programación que se benefician de ellas.
 ¿Qué es una lista en estructura de datos?
Una lista es una estructura de datos lineal que se
puede representar simbólicamente como un conjunto de
nodos enlazados entre sí. Las listas permiten modelar
diversas entidades del mundo real como por ejemplo, los
datos de los alumnos de un grupo académico, los datos del
personal de una empresa, los programas informáticos
almacenados en un disco magnético, etc.

Ejemplo de lista correspondiente a los nombres y apellidos

de un conjunto de alumnos con su código de matrícula.
 Características de las estructuras de datos
Dependiendo de su finalidad hay distintos tipos de estructura
de datos que pueden utilizarse y que aportan unas
características determinadas en cada uno de los casos. Uno de
los tipos más utilizados es el registro, un tipo de estructura
que reúne datos que han sido agregados. Con este tipo de
estructura lo que hacemos es unificar un valor con otra serie de
valores relacionados formando una secuencia.

También existe el vector, que concentra elementos dando

lugar a una estructura ordenada y relacionada. Sus datos
coinciden en formar parte de un tipo concreto y en estar
colocados en un orden determinado. Para una mejor facilidad de
uso se aplican palabras de memoria que ayudan a su
organización, mientras que también hay que tener en cuenta que
es factible que los arreglos puedan sufrir cambios de tamaño.

De forma derivada el vector asociativo permite que sean

eliminados pares nombre-valor dependiendo de las exigencias
del programador y del contexto. Otro tipo de estructura es la que
está representada por la unión, en la cual se unen distintos
datos, pero diferenciándose del registro debido a que solo se da
cobijo a un valor determinado.
 Métodos de las estructuras de datos

Tipos de ordenamiento:

 Ordenamiento interno: Trabajan en memoria principal y sus

implementaciones son muy variadas, de manera que la elección del
algoritmo adecuado debe realizarse con criterios de eficiencia (tiempo
y ejecución) y en función de la memoria disponible.
 Ordenación por intercambio (Burbuja): Es uno de los métodos
relativamente más sencillo e intuitivo, pero también resulta ser muy
ineficiente. Se basa en la ordenación por cambio, y recibe su nombre
de la semejanza con las burbujas de un depósito de agua donde cada
burbuja busca su propio nivel. Consideremos el siguiente ejemplo. Se
cuenta con un vector de 6 posiciones donde se inicia una lista de
números { 7, 2, 8, 3, 5, 1 }, la cual será ordenada en forma ascendente
{ 1, 2, 3, 5, 7, 8 }, observe como se declara una variable constante
entera llamada n la cual tiene un valor de 6, enseguida se declara un
vector de tipo entero
 que contendrá una cantidad n de casillas, en este caso 6,
declaramos también las variables i y j que nos ayudaran a
desplazarnos entre casilla y casilla para hacer las
comparaciones. Y finalmente la variable tem, almacenara
temporalmente el valor a intercambiar entre las casillas que
lo necesiten.

 Método de selección: La idea básica es encontrar el

elemento más pequeño (grande), en orden ascendente de
la lista, e intercambiarlo con el elemento que ocupa la
primera posición en la lista, a continuación se busca el
siguiente elemento más pequeño y se transfiere a la
segunda posición. Se repite el proceso hasta que el último
elemento ha sido transferido a su posición correcta. El
algoritmo de ordenación depende a su vez del algoritmo
necesario para localizar el componente mayor (menor) de
un array. Es un proceso muy similar al método de la
burbuja pero haciendo más eficiente la búsqueda y
evitando intercambios innecesarios.
 Método de inserción: Este método también se denomina
“método del jugador de cartas”, por la semejanza con la
forma de clasificar las cartas de una baraja, insertando cada
11
carta en el lugar adecuado. El algoritmo ordena los dos
primeros elementos de la lista, a continuación el tercer
elemento se inserta en la posición que corresponda, el
cuarto se inserta en la lista de tres elementos, y así
sucesivamente. Este proceso continua hasta que la lista este
totalmente ordenada. Sea una lista A[1], A[2], ... A[n]. Los
pasos a dar para una ordenación ascendente son:

1. Ordenar A[1] y A[2].

2. Comparar A[3] con A[2], si A[3] es mayor o igual a que
A[2], sigue con el siguiente elemento si no se compara A[3]
con A[1]; si A[3] es mayor o igual que A[1], insertar A[3]
entre A[1] yA[2]. Si A[3] es menor que A[1], entonces
transferir A[3] a A[1], A[1] a A[2] y A[2] a A[3].
3. Se suponen ordenados los n-1 primeros elementos y
corresponde insertar el n-ésimo elemento. Si A[m] es mayor
que A[k] (con K = 1, 2, ..., m-1), se debe correr una posición
A[k+1], ... A[m-1] y almacenar A[m] en la posición k+1.
 Ordenación Shell: La idea básica de este método es
distribuir el arreglo de manera que se genere una matriz de
valores donde cada elemento es comparado de manera
adyacente empleando un mecanismo de inserción directa
simple, dicho rango que genera grupos de manera matricial
que es reducido gradualmente hasta estabilizarse en un
valor uniforme de 1. Si el elemento a insertar es más
pequeño que el grupo de elementos que se encuentran a
su izquierda, será necesario efectuar varias comparaciones
antes de su ubicación. Shell propone que las
comparaciones entre elementos se efectúen con saltos de
mayor tamaño, pero con incrementos decrecientes; así, los
elementos quedaran ordenados más rápidamente.
 Ordenación por partición e intercambio: Es un algoritmo
relativamente eficiente y representa una mejora
sustancial al método de intercambio directo. El algoritmo
es el siguiente:
1. Elegir un elemento de la lista de elementos a ordenar
(pivote).
2. Resituar los demás elementos de la lista a cada lado
del pivote, de manera que a un lado queden todos los
menores que él, y al otro los mayores. Los elementos
iguales al pivote pueden ser colocados tanto a su
derecha como a su izquierda, dependiendo de la
implementación deseada. En este momento, el pivote
ocupa exactamente el lugar que le corresponderá en la
lista ordenada.
3. La lista queda separada en dos sub-listas, una
formada por los elementos a la izquierda del pivote, y
otra por los elementos a su derecha.
4. Repetir este proceso de forma recursiva para cada
sub-lista mientras éstas contengan más de un elemento.
Una vez terminado este proceso todos los elementos
estarán ordenados.
 Ordenamiento basado en comparaciones: Es una variante del
algoritmo de selección, El ordenamiento por montículos (Heap
sort) es un algoritmo de ordenación no recursivo, no estable,
con complejidad computacional O(n log n). Este algoritmo
consiste en almacenar todos los elementos del vector a
ordenar en un montículo (heap), y luego extraer el nodo que
queda como nodo raíz del montículo (cima) en sucesivas
iteraciones obteniendo el conjunto ordenado. Basa su
funcionamiento en una propiedad de los montículos, por la
cual, la cima contiene siempre el menor elemento (o el mayor,
según se haya definido el montículo) de todos los
almacenados en él.

 Ordenamiento Externo: La ordenación de archivos se lleva a

cabo cuando el volumen de los datos a tratar es demasiado
grande y los mismos no caben en la memoria principal de la
computadora. Al ocurrir esta situación no pueden aplicarse los
métodos de ordenación interna, de modo que debe pensarse
en otro tipo de algoritmos para ordenar datos almacenados en
archivos.
 Ordenación por mezcla directa: El método de ordenación
por mezcla directa es probablemente el más utilizado por
su fácil comprensión. La idea central de este algoritmo
consiste en la realización sucesiva de una partición y una
fusión que produce secuencias ordenadas de longitud
cada vez mayor. En la primera pasada la participación es
de longitud 1 y la fusión o mezcla produce secuencias
ordenadas de longitud 4. Este proceso se repite hasta que
la longitud de la secuencia para la partición sea mayor o
igual que la longitud de la secuencia para la partición sea
mayor o igual que el número de elementos del archivo
original. Supóngase que se desean ordenar las claves del
archivo F. Para realizar tal actividad se utilizan dos
archivos auxiliares a los que se les denominará F1 y F2.
F: 09 75 14 68 29 17 31 25 04 05 13 18 72 46 61
1) Primer chequeo
Partición en secuencias de longitud 1.
F1: 09 14 29 31 04 13 72 61
F2: 75 68 17 25 05 18 46
Fusión en secuencias de longitud 2.
F1: 09 75 14 68 17 29 25 31 04 05 13 18 46 72 61
2) Segundo chequeo
Partición en secuencias de longitud 2.
F1: 09 75 17 29 04 05 46 72
F2: 14 68 25 31 13 18 61
Fusión en secuencias de longitud 4.
F1: 09 14 68 75 17 25 29 31 04 05 13 18 46 61 72
3) Tercer chequeo
Partición en secuencias de longitud 4.
F1: 09 14 68 75 04 05 13 18
F2: 17 25 29 31 46 61 72
Fusión en secuencias de longitud 8.
F1: 09 14 75 25 29 31 68 75 04 05 13 18 46 61 72
4) Cuarto chequeo
Partición en secuencias de longitud 8.
F1: 09 14 17 25 29 31 68 75 F2: 04 05 13 18 46 61 72
Fusión en secuencias de longitud 16.
F1: 04 05 09 13 14 17 18 25 29 31 46 61 68 72 75
 Eliminar

Insertar Buscar

Operaciones
Básicas de
una lista

Vaciar Recorrer

Tamaño
Importancia de la estructura de datos

Es muy importante para los programadores porque es muy

útil para organizar diferente tipo de datos, así de esta manera
los datos se pueden usar de una forma muy eficiente y más fácil
de manejar y manipular. Las listas son una secuencia de nodos,
en los que se almacenan campos de datos arbitrarios y una o
dos referencias, enlaces o punteros al nodo anterior o posterior.

La ventaja de es usar listas en una estructura de datos

respecto a otros métodos (vectores) es que el orden los
elementos enlazados puede ser diferente al orden de
almacenamiento en la memoria o el disco, permitiendo que el
orden de recorrido de la lista sea diferente al de
almacenamiento. Las listas son un tipo de datos auto
referenciados, existe un elemento que sirve de referencia a las
operaciones de inserción, supresión y consulta. En una lista,
cada elemento apunta al siguiente excepto el último que no
tiene sucesor y el valor del enlace es nulo. Por ello los
elementos son registros que contienen el dato a almacenar y un
enlace al siguiente elemento. Para que esta estructura sea un
TDA lista, debe tener unos operadores asociados que permitan
la manipulación de los datos que contiene.
 Resolución de Ejercicios
1) Elabore un registro para n alumnos de una Universidad,
con sus respectivas notas de Programación II y
Estructuras de Datos, dichos datos, se deben guardar en
una Lista lineal. Se sabe que, en ésta universidad, existe
la política que sí, un alumno ha reprobado estas dos
materias, es dado de baja en la universidad. (Nota
mínima 9.5).

Codigo Fuente C++:

#include<iostream>
#include <string.h>
#include <cstdlib>
using namespace std;
int strcmp(const char[], const char[]);

struct E_Alumno{
char* nombre;
char* apellido;
float nota1;
float nota2;
};
typedef E_Alumno* alumno;

alumno crear_alumno(){
alumno x=new E_Alumno;
x->nombre=new char[50];
x->apellido=new char[50];
return x;
}
void liberar_alumno(alumno x){
delete[] x->nombre;
delete[] x->apellido;
delete[] x;
}

alumno leer_alumno(alumno x){

cout<<"Nombre del alumno: ";
cin.getline(x->nombre,50);
while(strlen(x->nombre)==0){
cin.getline(x->nombre,50);
}
cout<<"\nApellido del alumno: ";
cin.getline(x->apellido,50);
while(strlen(x->apellido)==0){
cin.getline(x->apellido,50);
}
cout<<"\nMensaje del sistema: Si ambas notas (Programacion II y Estructura de
Datos) \nestan por debajo de 9.5 se reconocera como 0, es decir se le dara de baja
\nal estudiante.\n\n";
cout<<"\nNota de Programacion:";

cin>>x->nota1;
while(x->nota1<0){
Bloque 1
cout<<"No es valido, ingrese la nota del estudiante";
cin>>x->nota1;
}

cout<<"\nNota de Estructura de Datos:";

cin>>x->nota2;
while(x->nota2<0){
cout<<"No es valido, ingrese la nota del estudiante.\n\n";
cin>>x->nota2;
}
if (x->nota1 && x->nota2< 9.5){

x->nota1 = 0;
x->nota2 = 0;

}
return x;

}
void imprimir_alumno(alumno x){
cout<<"\nInformacion del alumno\n";
cout<<"-------------------------\n";
cout<<"Nombre: \t"<<x->nombre;
cout<<"\nApellido: \t\t"<<x->apellido;
cout<<"\nNota de Programacion: \t"<<x->nota1<<"\n\n";
cout<<"\nNota de Estructura de Datos: \t"<<x->nota2<<"\n\n";
}

alumno* leer_conjunto_alumnos(alumno* c, int n){

for(int i=0;i<n;i++){
system ("cls");
cout<<"Alumno "<<i+1<<":\n\n";
alumno a=crear_alumno();
a=leer_alumno(a);
c[i]=a;
}
return c;
}
void imprimir_conjunto_alumnos(alumno* c, int n){
cout<<"NOMBRE \t\tAPELLIDO \t\tNOTA PROG \t\t NOTA ESTRC\n";
for(int i=0;i<n;i++){
cout<<c[i]->nombre<<"\t\t"<<c[i]->apellido<<"\t\t\t";
cout<<c[i]->nota1<<"\t\t\t "<<c[i]->nota2<<"\n";
}
}

alumno* ordenar_por_nota1(alumno* c, int n){

alumno aux;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(c[j]->nota1>c[i]->nota1){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}
}
}
return c;
}

alumno* ordenar_por_nota2(alumno* c, int n){

alumno aux;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(c[j]->nota2>c[i]->nota2){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}
}
}
return c;
}
alumno* ordenar_por_apellido(alumno* c, int n){
alumno aux;

for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if((c[j]->apellido)[0]<(c[i]->apellido)[0]){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}

}
}
return c;
}

alumno* ordenar_por_nombre(alumno* c, int n){

alumno aux;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if((c[j]->nombre)[0]<(c[i]->nombre)[0]){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}
}
}
return c;
}
void ordenar(alumno* c,int n,int x){
switch(x){
case 1:
cout<<"\n___________________________________\n";
cout<<"\nALUMNOS ORDENADOS POR NOMBRE\n";
cout<<"___________________________________\n\n";
c=ordenar_por_nombre(c,n);
imprimir_conjunto_alumnos(c,n);
break;
case 2:
cout<<"\n___________________________________\n";
cout<<"\nALUMNOS ORDENADOS POR APELLIDO\n";
cout<<"___________________________________\n\n";
c=ordenar_por_apellido(c,n);
imprimir_conjunto_alumnos(c,n);
break;

default:
cout<<"\n Opcion invalida."<<endl;

int main(){
int n=0;
cout<<"Cantidad de alumnos que desea ingresar: \n";
cin>>n;
alumno* conjunto=new alumno[n];
conjunto=leer_conjunto_alumnos(conjunto,n);
cout<<"\n___________________________________\n";
system ("cls");
cout<<"\nALUMNOS INGRESADOS POR EL USUARIO\n";
cout<<"___________________________________\n\n";
imprimir_conjunto_alumnos(conjunto,n);

int y;
printf ("\nSeleccione un metodo de orden.\n\n");
printf ("\n1.-Ordenar por Nota de Programacion II.\n");
printf ("2.-Ordenar por Nota de Estructuras de Datos.\n");
scanf ("%d", &y);
if(y == 1){
system ("cls");
cout<<"\nALUMNOS INGRESADOS POR EL USUARIO\n";
cout<<"___________________________________\n\n";
imprimir_conjunto_alumnos(conjunto,n);
conjunto=ordenar_por_nota1(conjunto,n);
cout<<"\n___________________________________\n";
cout<<"\nALUMNOS ORDENADOS POR NOTA DE PROGRAMACION\n";
cout<<"___________________________________\n\n";

imprimir_conjunto_alumnos(conjunto,n);

}
else if (y == 2){
system ("cls");
cout<<"\nALUMNOS INGRESADOS POR EL USUARIO\n";
cout<<"___________________________________\n\n";
imprimir_conjunto_alumnos(conjunto,n);
conjunto=ordenar_por_nota2(conjunto,n);
cout<<"\n___________________________________\n";
cout<<"\nALUMNOS ORDENADOS POR NOTA DE ESTRUCTURA DE DATOS\n";
cout<<"___________________________________\n\n";

imprimir_conjunto_alumnos(conjunto,n);

else{

printf ("Opcion invalida, debe ser entre 1 y 2.");

conjunto=leer_conjunto_alumnos(conjunto,n);
}
cout<<"\n";
cout<<"\n";
cout<<"\n";
cout<<"Presione 1 o 2 si quiere el ordenamiento por nombre o"<<endl<<"apellido
respectivamente, 3 para salir."<<endl;
int o;
cin>>o;
if (o == 3){
system ("cls");
printf ("Gracias por usar este sistema !! \n\n");
return 0;
}
while(0<=o<3){
if (o == 3){
system ("cls");
printf ("Gracias por usar este sistema !! \n\n");
return 0;
}

ordenar(conjunto,n,o);
cout<<"\n";
cout<<"Presione 1 o 2 si quiere el ordenamiento por nombre o"<<endl<<"apellido
respectivamente, 3 para salir."<<endl;
cin>>o;

}
system("pause");
}
2) El aeropuerto internacional de El Salvador, desea controlar el
flujo de pasajeros, y de aerolíneas que circulan por él. Diseñe un
programa que de soporte a las salidas y entradas de los aviones,
mediante una lista simple cuya información sería la siguiente:
Destino, compañía, hora de salida y pasajeros. Luego, y a partir
de ese último dato, es que se eliminarán los datos de la lista de
pasajeros.

Codigo Fuente C++:

#include<iostream>
#include <string.h>
#include <cstdlib>

using namespace std;

int strcmp(const char[], const char[]);
int hh;
int mm;
char t;
int k = 0;
int pasajeros;
truct E_Avion{
char* destino;
char* compania;
int hh;
int mm;
char c;
int pasajeros;
};

typedef E_Avion* avion;

avion crear_avion(){
avion x=new E_Avion;
x->destino=new char[50];
x->compania=new char[50];
return x;
}
void liberar_avion(avion x){
delete[] x->destino;
delete[] x->compania;
delete[] x;
}
avion leer_avion(avion x){
cout<<"Destino: ";
cin.getline(x->destino,50);
while(strlen(x->destino)==0){
cin.getline(x->destino,50);
}
cout<<"\nCompania: ";
cin.getline(x->compania,50);
while(strlen(x->compania)==0){
cin.getline(x->compania,50);
}
system ("cls");
cout<<"Nota Importante: Debe colocar HORAS seguido de : para luego colocar
MINUTOS. \n\nEjemplo: 09:30\n\n";
cout<<"\nHora de salida:";

cin>>x->hh >> t >> mm;

while((x->hh && mm<0) || (x->hh<0)){
cout<<"No es valido, ingrese una hora correcta";
cin>>x->hh >> t >> mm;
}

cout<<"\nPasajeros:";
cin>>x->pasajeros;
while(x->pasajeros<0){
cout<<"No es valido, ingrese una hora correcta.\n\n";
cin>>x->pasajeros;

return x;

void imprimir_avion(avion x){

cout<<"\nInformacion del vuelo\n";
cout<<"-------------------------\n";
cout<<"Destino: \t"<<x->destino;
cout<<"\nCompania: \t\t"<<x->compania;
cout<<"\nHora de Salida: \t"<<x->hh << ':' << mm<<"\n\n";
cout<<"\nPasajeros: \t"<<x->pasajeros<<"\n\n";
}
avion* leer_conjunto_aviones(avion* c, int n){
for(int i=0;i<n;i++){
system ("cls");
cout<<"Vuelo "<<i+1<<":\n\n";
avion a=crear_avion();
a=leer_avion(a);
c[i]=a;
}
return c;
}
void imprimir_conjunto_aviones(avion* c, int n){
cout<<"DESTINO \t\tCOMPANIA \t\tHORA DE SALIDA \t PASAJEROS\n";
for(int i=0;i<n;i++){
cout<<c[i]->destino<<"\t\t\t"<<c[i]->compania<<"\t\t\t";
cout<<c[i]->hh << ':' << mm<<"\t \t "<<c[i]->pasajeros<<"\n";
}
}

avion* ordenar_por_hora(avion* c, int n){

avion aux;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(c[j]->hh&&mm>c[i]->hh&&mm){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}
}
}
return c;
}
avion* ordenar_por_pasajeros(avion* c, int n){
avion aux;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(c[j]->pasajeros>c[i]->pasajeros){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}
}
}
return c;
}
avion* ordenar_por_compania(avion* c, int n){
avion aux;

for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if((c[j]->compania)[0]<(c[i]->compania)[0]){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}

}
}
return c;
}

avion* ordenar_por_destino(avion* c, int n){

avion aux;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if((c[j]->destino)[0]<(c[i]->destino)[0]){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}
}
}
return c;
}
void ordenar(avion* c,int n,int x){
switch(x){
case 1:
cout<<"\n___________________________________\n";
cout<<"\nVUELOS ORDENADOS POR DESTINO\n";
cout<<"___________________________________\n\n";
c=ordenar_por_destino(c,n);
imprimir_conjunto_aviones(c,n);
break;
case 2:
cout<<"\n___________________________________\n";
cout<<"\nVUELOS ORDENADOS POR COMPANIA\n";
cout<<"___________________________________\n\n";
c=ordenar_por_compania(c,n);
imprimir_conjunto_aviones(c,n);
break;

default:
cout<<"\n Opcion invalida."<<endl;

}
}

int n=0;
cout<<"Cantidad de vuelos que desea ingresar: \n";
cin>>n;
avion* conjunto=new avion[n];
conjunto=leer_conjunto_aviones(conjunto,n);
cout<<"\n___________________________________\n";

cout<<"\nVUELOS INGRESADOS POR EL USUARIO\n";

cout<<"___________________________________\n\n";
imprimir_conjunto_aviones(conjunto,n);

int y;
printf ("\nSeleccione un metodo de orden.\n\n");
printf ("\n1.-Ordenar por Hora de salida.\n");
printf ("2.-Ordenar por cantidad de Pasajeros.\n");
scanf ("%d", &y);
if(y == 1){

cout<<"\nVUELOS INGRESADOS POR EL USUARIO\n";

cout<<"___________________________________\n\n";
imprimir_conjunto_aviones(conjunto,n);
conjunto=ordenar_por_hora(conjunto,n);
cout<<"\n___________________________________\n";
cout<<"\nVUELOS ORDENADOS POR HORA DE SALIDA\n";
cout<<"___________________________________\n\n";

imprimir_conjunto_aviones(conjunto,n);

}
else if (y == 2){

cout<<"\nVUELOS INGRESADOS POR EL USUARIO\n";

cout<<"___________________________________\n\n";
imprimir_conjunto_aviones(conjunto,n);
conjunto=ordenar_por_pasajeros(conjunto,n);
cout<<"\n___________________________________\n";
cout<<"\nVUELOS ORDENADOS POR CANTIDAD DE PASAJEROS\n";
cout<<"___________________________________\n\n";

imprimir_conjunto_aviones(conjunto,n);

else{

printf ("Opcion invalida, debe ser entre 1 y 2.");

conjunto=leer_conjunto_aviones(conjunto,n);
}
cout<<"\n";
cout<<"\n";
cout<<"\n";
cout<<"Presione 1 o 2 si quiere el ordenamiento por destino o"<<endl<<"compania
respectivamente, 3 para salir."<<endl;
int o;
cin>>o;
if (o == 3){

printf ("Gracias por usar este sistema !! \n\n");

return 0;
}
while(0<=o<3){
if (o == 3){

printf ("Gracias por usar este sistema !! \n\n");

return 0;
}

ordenar(conjunto,n,o);
cout<<"\n";
cout<<"Presione 1 o 2 si quiere el ordenamiento por destino o"<<endl<<"compania
respectivamente, 3 para salir."<<endl;
cin>>o;

}
system("pause");
}
2) Una biblioteca, desea tener un registro de los libros que en ella
se encuentran, se sabe que existe un número no mayor a 100
libros, y que los datos que se necesitan registrar son: el nombre
del autor, el título del libro y las existencias del mismo. , Dichos
datos, se deben guardar en una Lista lineal.

Código Fuente C++:

#include<iostream>
#include <string.h>
#include <cstdlib>
using namespace std;
int strcmp(const char[], const char[]);

struct E_Libro{
char* titulo;
char* autor;

};
typedef E_Libro* libro;

libro crear_libro(){
libro x=new E_Libro;
x->titulo=new char[100];
x->autor=new char[100];
return x;
}
void liberar_libro(libro x){
delete[] x->titulo;
delete[] x->autor;
delete[] x;
}

libro leer_libro(libro x){

cout<<"Titulo del libro:";
cin.getline(x->titulo,50);
while(strlen(x->titulo)==0){
cin.getline(x->titulo,50);
}
cout<<"\nAutor del libro:";
cin.getline(x->autor,50);
while(strlen(x->autor)==0){
cin.getline(x->autor,50);
}

return x;

}
void imprimir_libro(libro x){
cout<<"\nInformacion del libro\n";
cout<<"-------------------------\n";
cout<<"Titulo:\t"<<x->titulo;
cout<<"\nAutor: \t\t"<<x->autor;

}
libro* leer_conjunto_libros(libro* c, int n){
for(int i=0;i<n;i++){
system ("cls");
cout<<"Libro "<<i+1<<":\n\n";
libro a=crear_libro();
a=leer_libro(a);
c[i]=a;
}
return c;
}

void imprimir_conjunto_libros(libro* c, int n){

cout<<"TITULO \t\t\t\tAUTOR \n";
for(int i=0;i<n;i++){
cout<<c[i]->titulo<<"\t\t\t"<<c[i]->autor<<"\n";

}
}
libro* ordenar_por_autor(libro* c, int n){
libro aux;

for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if((c[j]->autor)[0]<(c[i]->autor)[0]){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}

}
}
return c;
}
libro* ordenar_por_titulo(libro* c, int n){
libro aux;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if((c[j]->titulo)[0]<(c[i]->titulo)[0]){
aux=c[i];
c[i]=c[j];
c[j]=aux;
}
}
}
return c;
}

void ordenar(libro* c,int n,int x){

switch(x){
case 1:
system ("cls");

cout<<"___________________________________\n\n";
cout<<"\nLIBROS ORDENADOS POR TITULO\n";
cout<<"___________________________________\n\n";
c=ordenar_por_titulo(c,n);
imprimir_conjunto_libros(c,n);
break;
case 2:
system ("cls");

cout<<"___________________________________\n\n";
cout<<"\nLIBROS ORDENADOS POR AUTOR\n";
cout<<"___________________________________\n\n";
c=ordenar_por_autor(c,n);
imprimir_conjunto_libros(c,n);
break;

default:
cout<<"\n Opcion invalida."<<endl;

}
int main(){
int n=0;
cout<<"Cantidad de libros que desea ingresar: \n";
cin>>n;
libro* conjunto=new libro[n];
conjunto=leer_conjunto_libros(conjunto,n);
cout<<"\n___________________________________\n";
system ("cls");
cout<<"\nLIBROS INGRESADOS POR EL USUARIO\n";
cout<<"___________________________________\n\n";
imprimir_conjunto_libros(conjunto,n);

cout<<"\n";
cout<<"\n";
cout<<"\n";
cout<<"Presione 1 o 2 si quiere el ordenamiento por titulo o"<<endl<<"autor
respectivamente, 3 para salir."<<endl;
int o;
cin>>o;
if (o == 3){
system ("cls");
printf ("Gracias por usar este sistema !! \n\n");
return 0;
}
while(0<=o<3){
if (o == 3){
system ("cls");
printf ("Gracias por usar este sistema !! \n\n");
return 0;
}

ordenar(conjunto,n,o);
cout<<"\n";
cout<<"Presione 1 o 2 si quiere el ordenamiento por titulo o"<<endl<<"autor
respectivamente, 3 para salir."<<endl;
cin>>o;
}
system("pause");
}
 Conclusión
Los tipos de estructuras de datos que se usan en la
programación también son similares a los que encuentras en tu día
a día. Por ejemplo, las camisetas de tu armario probablemente
estén una encima de la otra. En cada lenguaje de programación
podemos usar diferentes estructuras de datos y diferentes
implementaciones de las más básicas, como las listas, colas, pilas,
que suelen estar presentes en la mayoría de los lenguajes. Si
entendemos el concepto, importa poco la sintaxis, porque la
podremos realizar nosotros mismos en términos de código o la
encontraremos en diversas fuentes como libros o tutoriales.

Es muy importante conocer las estructuras de datos más

comunes que se utilizan en la programación, ya que la estructura
de datos es vital para plantear el problema y al resolverlo, poder
implementar su solución eficazmente. Sin abandonar la sencillez
se abordaron otras estructuras de datos más complejas, como las
listas y sus comportamientos: pilas y colas.

Para saber cómo son y cómo se comportan estas estructuras

de datos simples, piensa en lo siguiente: los platos para fregar en
la cocina se organizan en una pila. Los platos sucios se colocan
encima del todo y cuando vas a fregarlos el primero que tomas es
el que tienes arriba.