ALGORITMOS Y ESTRUCTURAS DE DATOS

CLASE 1 - 04/05/2017

Matrícula Nombre

1066179 Moises R. Diaz De La Paz

1064452 Jhonncell Jimenez P.

1066903 Haziel Sánchez

1066902 Sarah Pérez

1066512 Jorge Moreta

1. ¿Qué es un algoritmo?

Un algoritmo es el conjunto de pasos a seguir para resolver un problema. Tiene que

ser preciso, es decir, el conjunto de pasos que se llevará a cabo debe estar
claramente definido a fin de que se pueda utilizar el algoritmo para crear el código
fuente. Un algoritmo NO tiene que ser bueno o rápido, es decir, estas no son
cualidades que lo definen.

Es importante diferenciar entre ​Algoritmo​, ​Código Fuente​ y ​Programa​.

● Algoritmo​: es una idea, se puede describir.

● Código Fuente (source code)​: materialización de un algoritmo, traducción a
un lenguaje de programación.
● Programa​: compilación del código fuente.

Algoritmo Código Fuente (source code) Programa

2. Razones para estudiar Algoritmos y Estructuras de Datos

Para poder realizar buenos algoritmos, que sean eficientes en el uso de recursos y
de (relativamente) rápida ejecución. La eficiencia también trae beneficios como el
fácil mantenimiento que se le puede dar al source code. Otra razón para estudiar
algoritmos y estructuras de datos es que son partes vitales del desarrollo. El avance
tecnológico en las últimas décadas se debe a Hardware y Software:
Hardware: Según la Ley de Moore (Que es una observación o proyección y no una
ley), un ingeniero de INTEL, los recursos de un procesador se duplican cada uno o
dos años, pero, se dice que ya no se está aplicando porque físicamente estamos
llegando al límite.

Software (Parte algorítmica): En esta parte también estamos llegando al límite, ya

que los algoritmos están siendo perfeccionados.

3. Operaciones primitivas

Son las operaciones que el computador hace instantáneamente. Estas son:

❏ “+”, “-”, “/”, “*”, “%”
❏ “<”, “>”, “<=”, “>=”, “==”, “!=”, “&&”, “||”, “!”
❏ Acceder al valor de una variable.
❏ Asignarle un valor a una variable.
❏ Acceder a la posición de un arreglo (A[i]).
❏ Llamar una función o método.
❏ Crear un objeto.
❏ Desreferenciar un atributo de un objeto.
❏ Retornar valores en una función.

4. Análisis de algoritmos / Complejidad de algoritmos

¿Cómo se mide la eficiencia de un algoritmo?

Podríamos comparar dos algoritmos tomando en cuenta el tiempo, pero esto tendría
varios problemas: el tiempo del proceso de un algoritmo varía dependiendo del
computador; el compilador que se utilice tiene influencias en este proceso; también
influyen las demás tareas que se estén realizando en segundo plano en el
computador.

Una forma válida de medir esta eficiencia consiste en contar las operaciones
primitivas que se realizan en el algoritmo, de esta manera, terminaríamos con una
función polinómica de complejidad “n”, con un aspecto parecido al siguiente:

Para describir el comportamiento en el límite (cuando x -> ∞) se utiliza la notación Big-O

(Big-O notation), donde el coeficiente a​n y todos los sumandos excepto a​n​x​n pueden
ignorarse, ya que su impacto es despreciable con respecto al impacto de x​n​.
 5. Ejemplos

Ejemplo 1​: Función que cuenta la cantidad de números divisibles entre 3 y 5 en una
lista de números enteros.

int​ multiplos_de_3y5​(​int​[]​ A)
{​ ​// N = A.length
​int​ result ​=​ ​0​;​ ​// +1
​for​ ​(​ ​int​ i ​=​ ​0​;​ i ​<​ A​.​length​;​ i​++​ ​)​ ​// +1 +4(N+1) +3N
{
​if​ ​(​ ​(​A​[​i​]​ ​%​ ​3​)​ ​==​ ​0​ ​&&​ ​(​A​[​i​]​ ​%​ ​5​)​ ​==​ ​0​ ​)​ ​// +5N +5N +N
{
result​++;​ ​// +3N
}
}
​return​ result​;​ ​// +1
​// 21N+7 operaciones primitivas (según lo expuesto en la sección 3)
}

Ejemplo 2​: Función que cuenta la cantidad de parejas de números en una lista de
números enteros distintos, que suman un número dado T.
*No se puede contar como pareja un número con sí mismo.

int​ parejas_que_suman_T​(​int​[]​ A​,​ ​int​ T)

{
​// N = A.length
​int​ result ​=​ ​0​;​ ​// +1
​for​ ​(​ ​int​ i ​=​ ​0​;​ i ​<​ A​.​length​;​ i​++​ ​)​ ​// +1 +4(N+1) +3N
​ {
​for​ ​(​ ​int​ j ​=​ ​0​;​ j ​<​ A​.​length​;​ j​++​ ​)​ ​// +N +4(N+1)N +3N²
{
​if​ ​(​ ​(​i ​!=​ j​)​ ​&&​ ​(​A​[​i​]​ ​+​ A​[​j​]​ ​==​ T​)​ )
​ ​ ​// +3N² +N² +7N²
{
result​++;​ ​// 3N²
}
}
}
​return​ result​;​ ​// +1
​// 21N²+12N+6 operaciones primitivas (según lo expuesto en la sección 3)
}