FACULTAD DE INGENIERÍA

CARRERA DE INGENIERÍA SISTEMAS COMPUTACIONALES

COMPLEJIDAD DE
ALGORITMOS

Autor:

VELIZ FERNANDEZ, CHRISTIAN CARLOS N00158631

Curso:

ANALISIS DE ALGORITMO Y ESTRATEGIAS DE PROGRAMACIÓN

Docente:

MONDRAGÓN VILELA, MANUEL RICARDO

ÍNDICE
 2

INTRODUCCIÓN......................................................................................................... 3
1. MARCO TEÓRICO............................................................................................... 4
1.1. OBJETIVOS GENERALES........................................................................................................4
1.2. OBJETIVO ESPECIFICO..........................................................................................................4
2. ANALISIS TEORICO............................................................................................ 4
2.1. COMPLEJIDAD...........................................................................................................................4
2.1.1. COMPLEJIDAD ASINTÓTICA……………………………………………………………………4
2.2. ALGORITMO...............................................................................................................................5
2.3. ALGORITMOS DE ORDENAMIENTO.....................................................................................5
2.4. PROGRAMACION......................................................................................................................5
2.5. JAVA 6
2.6. NETBEANS..................................................................................................................................6
2.7. METODO......................................................................................................................................6
2.8. CLASE..........................................................................................................................................7
2.9. INSTANCIAS...............................................................................................................................7
3. EJEMPLO DE ALGORITMO DE ORDENAMIENTO BURBUJA................................8
3.1. ANALISIS.....................................................................................................................................9
4. CONCLUSIONES............................................................................................... 10
5. BIBLIOGRAFÍA................................................................................................... 11
 3

INTRODUCCIÓN

En el desarrollo de un programa, es importante definir criterios para poder medir su

rendimiento; los cuales deben estar centrados principalmente en su simplicidad y en el uso

eficiente de los recursos.

Dependiendo de la cantidad de datos que se le ingrese, cada algoritmo se comportara de

manera diferente.

Según [ CITATION Gil14 \l 10250 ] “La complejidad en sí que es para un tamaño n

tardará un tiempo y para un tiempo mayor cumplirá f(n2) la complejidad nos describe el

tipo de curva que cumplirá esa función f. Esto lo representamos como O(f).”

Así mismo según [ CITATION Gil14 \l 10250 ] “El tiempo que tardará para un tamaño

n es llamado tiempo de ejecución. Esto es lo representamos como T(n).”

Entonces es evidente que se debe buscar o trabajar en algoritmos que consuman en lo

posible la cantidad necesaria de recursos de sistema, en pocas palabras que sea lo más

eficiente posible.

Podemos tener algoritmos que realicen lo mismo, sin embargo, siempre uno será más

eficiente que el otro y para analizar ello es necesario analizar la complejidad para poder

determinar cual es el mejor en dos aspectos importantes, tiempo y consumo.

 4

1. MARCO TEÓRICO

1.1. OBJETIVOS GENERALES

Obtener un conocimiento de la complejidad de los algoritmos en general a fin de poder

identificar los recursos que necesitan para resolver problemas y con ello dar a conocer que tan

eficiente es dicho algoritmo.

1.2. OBJETIVO ESPECÍFICO

 Identificar la complejidad en cada uno de los algoritmos estudiados.

 Poner en práctica los conocimientos adquiridos, en los diversos ejercicios que se

realice durante las clases y fuera, como parte de reforzamiento del conocimiento.

 Evaluar la complejidad algorítmica.

2. ANÁLISIS TEORICO

2.1. COMPLEJIDAD

Son los cálculos mínimos y máximos que realiza un algoritmo, representado por la

cantidad de recursos que utiliza el algoritmo para su ejecución, de esto depende que tan

eficiente es el mismo.

2.1.1. COMPLEJIDAD ASINTÓTICA

Según [ CITATION Lup17 \l 10250 ] “La notación asintótica nos permite representar la

complejidad, y por ende la eficiencia, de un algoritmo, de tal manera que podemos

proyectar el aumento de operaciones requeridas al aumentar el tamaño de la entrada

(input).”
 5

2.2. ALGORITMO

Según los autores [ CITATION Joy \l 10250 ]“Un algoritmo es un método para resolver

un problema mediante una serie de pasos precisos, definidos y finitos (la solución se

alcanza en tiempo definido)” (pág. 27).

Las características de un algoritmo son las siguientes:

 El algoritmo debe ser directo y preciso, así mismo, tiene que brindar el orden de

ejecución del paso a paso.

 El algoritmo en algún momento debe de terminar, por lo cual debe ser finito.

 Tras la ejecución de un algoritmo, este debe brindar el mismo resultado, por lo que

debe de estar definido.

2.3. ALGORITMOS DE ORDENAMIENTO

Es un algoritmo que coloca elementos de una lista o un vector en una secuencia dada por

una relación de orden, es decir, obtendremos como resultado de salida, una permutación o

reordenamiento de la entrada que satisfaga la relación de orden dada.

En otras palabras, nos permiten cambiar el orden de elementos que existen en una

estructura, moviendo elementos dentro de un vector para darles un orden lógico, generalmente

se espera que se ordene de menor a mayo o viceversa. Se puede utilizar este algoritmo frente a

cualquier cosa que sea ordenable, cualquier tipo de datos que tenga alguna propiedad que sea

por ejemplo números, meses, expedientes, libros, facturas, etc.

Existen algoritmos de ordenamiento que son unos más rápidos que otros al trabajar con los

datos.
 6

2.4. PROGRAMACIÓN

La programación es un proceso de transcribir un algoritmo escrito a un lenguaje de

programación el cual pueda ejecutar las líneas de código implementadas.

2.5. JAVA

Es un lenguaje flexible y practico, es un lenguaje de programación orientada a objetos, así

mismo es multiplataforma y gratis, sirve para base de datos, aplicaciones, interfaces yes muy

completo.

2.6. NETBEANS

Es un entorno de desarrollo integrado, nos ayuda a programar en java y en otros lenguajes

de programación, es multiplataforma.

Es un buen editor de código, multilenguaje, con el habitual coloreado y sugerencias de

código, acceso a clases pinchando en el código, control de versiones, localización de

ubicación de la clase actual, comprobaciones sintácticas y semánticas, plantillas de código

y herramientas de refactorización. También hay tecnologías donde podemos usar el pulsar

y arrastrar para incluir componentes en nuestro código. Esta herramienta permite a los

desarrolladores de software crear, de forma rápida, aplicaciones Java, PHP, JavaScript y

AJAX, Groovy y Grails [ CITATION Góm12 \l 10250 ].

2.7. MÉTODO

Son un conjunto de subprogramas dentro de una clase lo cual ahorra a no ser redundante y

tener un código más limpio, así mismo los métodos nos ayuda a optimizar los recursos del

hardware evitando la sobrecarga de y ejecución de las sentencias que se tenga en el programa.

 7

2.8. CLASE

Las clases son los bloques de construcción fundamentales de los programas orientados a

objetos. Una clase contiene la especificación de los datos que describen un objeto junto

con la descripción de las acciones que un objeto conoce cómo ha de ejecutar. Estas

acciones se conocen como servicios, métodos o funciones, miembro[CITATION Joy00 \p

266 \l 10250 ].

2.9. INSTANCIAS

Es un miembro de una clase que tiene atributos en lugar de variables.

El hecho de disponer de estas funciones permite al programador centrarse mejor en la

función específica requerida por los usuarios, sin tener que preocuparse de los detalles de

implementación de bajo nivel.

 8

3. EJEMPLO DE ALGORITMO DE ORDENAMIENTO BURBUJA

 9

3.1. ANÁLISIS

La complejidad del algoritmo de burbuja es el siguiente:

Mejor de los casos: O(n)

Peor de los casos: O(n^2)

Para:

f(x)= n+4m*n
 10

Esto aparece en burbujas o recursiones que son doblemente anidados como es el caso del

método trabajado.

Element Operacio

os nes
n n^2
10 100
20 400
30 900
40 1600
50 2500
60 3600
70 4900

4. CONCLUSIONES

Es importante elegir un algoritmo que sea estructurado y que sea eficiente ya que con esto

se tendrá el menor tiempo de respuesta y el consumo de recurso puede ser el justo.

Es necesario realizar el análisis de complejidad para poder tomar buenas decisiones que no

impacten en la solución final.

Los algoritmos que realizan la misma función, no son necesariamente iguales o parecidos.

Finalmente; el análisis de complejidad debe estar tanto en algoritmos pequeños como en

los más complejos.

5. BIBLIOGRAFÍA

Aguilar, J. (2000). Programacion en C++, algoritmos, estructuras de datos y objetos. España.

Gil, F. (2014). Complejidades típicas de un algoritmo. Rootear.
Gilfillan. (2003).
Gómez. (2012).
 11

Joyanes Aguilar, L., & Zahonero Martinez, I. (s.f.). Programacion en java. Mexico: Mc Graw
Hill.
Montero, L. (2017). Algoritmos y notación asintótica. Laboratoria Dev.
Quiroz, M. (2007).