ESTRUCTURA DE DATOS

Contenido
1. Encuentro: Programación Orientada a objetos................................................................1
 Clases...........................................................................................................................1
 Atributos y métodos.....................................................................................................2
 Objetos.........................................................................................................................3
 Arreglos........................................................................................................................3
2. Encuentro: Análisis de Algoritmos.................................................................................4
1. Complejidad temporal y espacial.................................................................................4
1.1 Procedimiento para calcular complejidad temporal de forma teórica..................5
1.2 Procedimiento para calcular complejidad espacial de forma teórica....................5
2. Notación asintótica y notación O grande.......................................................................5
3. Reglas para el cálculo de complejidad............................................................................6
4. Principales órdenes de complejidad................................................................................7
4.1. Orden constante O (1)..............................................................................................7
4.2 Orden logarítmico O (log n)......................................................................................7
4.3 Orden lineal O(n)......................................................................................................8
4.4 Orden n log de O (n log n)........................................................................................8
4.5 Orden cuadrático O(n2)............................................................................................9
4.6 Orden exponencial O(an)...........................................................................................9
5. Otras notaciones asíntotas diferentes a O grande..........................................................10
5.1. Notación asintótica Ω grande.................................................................................10
5.8. Notación asintótica Θ grande.................................................................................10
 1. Encuentro: Programación Orientada a objetos.
 Clases
Es abstracción de un conjunto de objetos reunidos bajo el mismo concepto.
Ex. Todos son perros. De pendiendo de la situación extraemos las características que nos
conciernen de los perros.

La abstracción es el proceso que se sigue para escoger únicamente las características que
resultan interesantes sobre los perros en un ámbito particular, con el objetivo de tener una
idea o modelo de lo que es un perro.
En java:

 Atributos y métodos
Una clase se define mediante:
 Un nombre que la identifica.
 Atributos de los objetos de la clase : Representan características de los objetos de la
clase
  Métodos asociados a los objetos de la clase: Representan comportamiento de los
objetos de la clase
o Los métodos se clasifican en:
 Constructores: son los responsables de crear nuevas instancias de la
clase.
 Analizadores: son los responsables de permitir consultas sobre los
atributos de la clase.
 Modificadores: son los responsables de permitir modificaciones sobre
los atributos de la clase.
 Objetos
 Un objeto es una instancia o particularización de una clase.

“Un objeto tiene estado, comportamiento e identidad; la estructura y

comportamiento de objetos similares están definidos en su clase común; los
términos instancia y objeto son intercambiables”

 Las propiedades de cada objeto son definidas mediante los valores que toman
sus atributos.
 Arreglos

Un arreglo, es una secuencia de elementos del mismo tipo que son almacenados de forma
contigua.
El acceso a los arreglos se realiza mediante índices desde 0 para la primera pose

2. Encuentro: Análisis de Algoritmos

Es conocido que la ejecución de todo algoritmo demanda recursos computacionales
 Procesador: se refleja en el consumo de tiempo utilizado para ejecutar las
instrucciones del programa.
 Memoria RAM: se refleja en el consumo de espacio ocupado por las variables
del programa.
 Disco duro.
 Recursos de red
Respecto a un recurso computacional, la complejidad de un algoritmo representa la
cantidad del recurso que el programa demanda para su ejecución.
La demanda de procesador se mide por medio de la complejidad temporal, mientras que la
demanda de memoria RAM se mide mediante la complejidad espacial.
 1. Complejidad temporal y espacial

Existen dos métodos para medir la complejidad, el práctico y el teórico.

Práctico: Inviable por las capacidades de los computadores. Su tiempo de ejecución
depende de distintos factores.
Teórico: Se implementa con mayor facilidad y que permite comparar los tiempos y los
espacios de memoria que deberían destinarse a distintos algoritmos.
En pocas palabras, la complejidad temporal mide el tiempo empleado y la complejidad
espacial mide el espacio requerido.

1.1 Procedimiento para calcular complejidad temporal de forma teórica

1. Identificar las variables que describen el tamaño del problema a resolver.

Ex: si se están sumando dos matrices de dimensiones n x m, el tamaño del

problema estaría descrito por la variable n (el alto de las matrices) y por la
variable m (el ancho de las matrices).

2. Definir las operaciones básicas que desea contabilizar.

En el ejemplo anterior de suma de matrices, importaría contar cuántas sumas de
celdas se realizan.

3. Encontrar una función que relacione el tamaño del problema con el número de
operaciones básicas ejecutadas, analizando el peor escenario posible.
Esta función refleja la complejidad temporal, porque entre más operaciones se
ejecuten, más tiempo se demoraría el algoritmo en ejecutar.

1.2 Procedimiento para calcular complejidad espacial de forma teórica

1. Identificar las variables que describen el tamaño del problema a resolver.

Ex: Si se están sumando dos matrices de dimensiones n x m, el tamaño del
problema estaría descrito por la variable n (el alto de las matrices) y por la
variable m (el ancho de las matrices).

2. Encuentre una función que relacione el tamaño del problema con el número de
variables declaradas en el programa.
 Esta función refleja la complejidad espacial porque entre más variables se declaren,
más espacio en memoria RAM requeriría el algoritmo para ejecutar
2. Notación asintótica y notación O grande

Notación asíntota: Forma de representación que permite describir la eficiencia de un

algoritmo en función de su tasa de crecimiento.
 Proyecta el comportamiento del algoritmo conforme al aumento del tamaño de
sus entradas.
 Proyecta el comportamiento de cada solución a entradas de gran tamaño.
 Su uso principal es la comparación de un conjunto de algoritmos para
determinar niveles de complejidad
Notación O grande: Se centra en un análisis del escenario más adverso imaginable.
 Aquello produce que la función ejecute el máximo número de operaciones
posible.
 Puede usarse para describir tanto complejidad temporal como espacial.
a. Dada una función f(n) se dice que un algoritmo tiene complejidad
temporal O(f(n)) si la cantidad de operaciones que ejecuta siempre está
por debajo de un múltiplo constante de f(n), para un valor grande de n.

 Similarmente, se define para la complejidad espacial, pero sobre la cantidad de

variables declaradas.
3. Reglas para el cálculo de complejidad

instrucción 1;
instrucción 2;
instrucción 3;
...
instrucción x;

Caso 1: Para calcular la complejidad temporal de una secuencia de instrucciones se

debe hallar la complejidad de cada instrucción por separado y tomar la más grande de
estas.

Variable=expresión;

Caso 2 Asignación: Para calcular la complejidad temporal de una asignación hay que
hallar la complejidad del cálculo de la expresión que está siendo asignada.
 if (condición){
instrucción 1;
instrucción 2;
instrucción 3;
...
instrucción x;
}
else{
instrucción x + 1;
instrucción x + 2;
instrucción x + 3;
...
instrucción y; }

Caso 3 Condicional: Para calcular la complejidad temporal de un condicional hay que

hallar la complejidad de evaluar la condición de cada instrucción por separado y tomar
la más grande de estas.
if for (int i=1; i<=n; i++){
instrucción 1;
instrucción 2;
instrucción 3;
...
instrucción x;}

Caso 4 Ciclo: Para calcular la complejidad temporal de un ciclo while o for se debe
multiplicar el número de iteraciones que hace el ciclo por la complejidad del cuerpo del
ciclo.
4. Principales órdenes de complejidad

Existen múltiples órdenes para clasificar la complejidad de los algoritmos; sin embargo,
hay un conjunto de ellos que es más común que los demás.
4.1. Orden constante O (1)
Representa la complejidad de un algoritmo que se ejecutará siempre en el mismo tiempo o
espacio, sin importar el tamaño de las entradas.

static double calcularArea(double r) {

return Math.PI * r * r; }
4.2 Orden logarítmico O (log n)
Es la complejidad de un algoritmo cuyo tiempo de ejecución se incrementará más
lentamente a medida que el tamaño del conjunto de entradas aumente.
static int busquedaBinaria(int arreglo[], int x) {
int centro,inferior=0,superior=arreglo.length-1;
while(inferior<=superior){
centro=(superior-inferior)/2+inferior;
if(arreglo[centro]==x)
return centro;
else if(x < arreglo[centro])
superior=centro-1;
else
inferior=centro+1;}
return -1;}

Algoritmo que realiza una búsqueda binaria.

Como el algoritmo hace divisiones sucesivas de dos para fraccionar el arreglo, se vuelve
comparativamente más eficiente a medida que el tamaño del arreglo aumenta.

4.3 Orden lineal O(n)

Es la complejidad de un algoritmo que se ejecutará en un tiempo que crecerá linealmente,
en proporción directa con el tamaño del conjunto de entradas.

static int busquedaSimple(int arreglo[], int x) {

for(int i=0; i<arreglo.length; i++){
if(x==arreglo[i]) {
return i;}}
return -1; }

Se asume el peor caso. Consistiría en la ejecución del máximo número de iteraciones

posible.
4.4 Orden n log de O (n log n)
Es la complejidad de un algoritmo que se ejecutará en un tiempo que crecerá de manera
aproximada a la lineal, pero, multiplicado por un factor que aumenta cada vez más
lentamente a medida que se incrementa el tamaño del conjunto de entradas.
static void mergeSort(int arreglo[]) {
if (arreglo.length == 1)
return;
int lista1[] = new int[arreglo.length/2];
for (int i=0; i<lista1.length;i++)
lista1[i]=arreglo[i];
int lista2[] = new int[arreglo.length-lista1.length];
for (int i=0; i<lista2.length;i++)
lista2[i]=arreglo[i+lista1.length];
mergeSort(lista1);
mergeSort(lista2);
merge(lista1, lista2, arreglo);
}
static void merge(int[] a, int[] b, int[] c) {
int i = 0;
int j = 0;
while(i<a.length && j<b.length) {
if (a[i] < b[j]) {
c[i+j] = a[i];
i++;}
else {
c[i+j] = b[j];
j++;}
}
while(i<a.length) {
c[i+j] = a[i];
i++;
}
while(j<b.length) {
c[i+j] = b[j];
j++;}
}

4.5 Orden cuadrático O(n2)

Es la complejidad de un algoritmo que se ejecutará en un tiempo que crecerá en proporción
directa con el cuadrado del tamaño del conjunto de entradas. Como siempre, para la
notación O, se asume el peor caso
 static boolean busquedaSimpleMatrizCuadrada(int matriz[][], int x) {
for(int i=0; i<matriz.length; i++){
for(int j=0; j<matriz.length; j++){
if(x==matriz[i][j]) {
return true;}
}
}
return false;}

En este caso sería la ejecución del máximo número de iteraciones posible

4.6 Orden exponencial O(an)

Es la complejidad de un algoritmo que se ejecutará en un tiempo que crecerá en un factor
de a con cada adición al conjunto de datos de entrada. Proporción directa con el cuadrado
del tamaño del conjunto de entradas.
static int fibonacci(int n) {
if (n==1 || n==2) {
return 1;}
else {
return fibonacci(n-1) + fibonacci(n-2);}
}
Este caso representa un algoritmo de complejidad O(2n) pues cada nueva
entrada dobla el tiempo de ejecución.
5. Otras notaciones asíntotas diferentes a O grande

En muchas situaciones, el peor caso de un algoritmo ocurre solo en situaciones

extraordinarias.
Ex: ejemplo un algoritmo cualquiera con complejidad temporal O(n2), que el 99.999% de
las veces se comporta como si tuviera complejidad temporal O(n), pero, que en el 0.001%
restante alcanza su peor caso y adquiere la complejidad temporal de O(n2).
Por esta razón, hay otros dos tipos de análisis que se pueden hacer sobre los algoritmos y
que son válidos tanto para el tiempo de ejecución como para el espacio en memoria
empleado.
5.1. Notación asintótica Ω grande

Se centra en analizar el mejor caso, es decir, en el escenario que se ejecuta el mínimo

número de operaciones posible.
Ex. Dada una función f(n) se dice que un algoritmo tiene complejidad temporal Ω (f(n)) si
la cantidad de operaciones que ejecuta siempre está por encima de un múltiplo constante
de f(n), para un valor grande de n.
5.8. Notación asintótica Θ grande

Se usa para describir la tasa de crecimiento en el mejor y el peor caso del tiempo de
ejecución, o el espacio de memoria empleado, de un algoritmo cuando la tasa es la misma.
Ex: Dada una función f(n) se dice que un algoritmo tiene complejidad temporal Θ(f(n)) si y
solo si el orden de complejidad en el mejor escenario es Ω (f(n)) y el orden de complejidad
en el peor escenario es O(f(n)).

La complejidad computacional representa la cantidad de recursos que un algoritmo

demanda para su ejecución. El recurso de mayor interés suele ser el tiempo de
ejecución. Asimismo, es más recurrente hacer análisis teóricos que análisis prácticos de
complejidad, debido a la dificultad de establecer condiciones iguales en cada proceso de
evaluación.
El análisis teórico se implementa por medio de la notación asintótica, que proyecta el
uso de un recurso a escenarios en que el conjunto de entradas del algoritmo es muy grande.
La notación asintótica tiene como objetivo fundamental permitir la comparación entre dos o
más soluciones diferentes a un problema.
La notación asintótica puede representar el peor escenario, cuando se ejecuta el
máximo número de operaciones posible; el mejor escenario, cuando se ejecuta el mínimo
número de operaciones posible; y el evento en que el mejor y el peor escenario tienen un
mismo orden de complejidad.