tema 2: algoritmos y programasinformatica.uv.es/mguia/asignatu/inf/2009_10...estructuras de control...

Licenciatura en Matemàtiques

Tema 2: Algoritmos y programas 1

TEMA 2: ALGORITMOS Y PROGRAMAS

TEMA 2: ALGORITMOS Y PROGRAMAS ......................................................................................................................1 INTRODUCCIÓN.....................................................................................................................................................................1

Análisis del problema .....................................................................................................................................................1 Búsqueda del algoritmo ..................................................................................................................................................1 Programación del algoritmo...........................................................................................................................................3

TIPOS DE DATOS SIMPLES......................................................................................................................................................4 ESTRUCTURAS DE CONTROL .................................................................................................................................................4

Estructuras secuenciales.................................................................................................................................................5 Estructuras selectivas .....................................................................................................................................................5 Estructuras repetitivas (o bucles) ...................................................................................................................................9

PROGRAMACIÓN MODULAR ................................................................................................................................................10 Ámbito de las variables.................................................................................................................................................11 Paso de parámetros ......................................................................................................................................................12

PROGRAMACIÓN ESTRUCTURADA.......................................................................................................................................13 RECURRENCIAS (O RECURSIVIDAD) ....................................................................................................................................13

Introducción

Un algoritmo es una sucesión finita de pasos no ambiguos, que se ejecutan en un tiempo finito, que le dicen al ordenador lo que hay que hacer en cada momento para llegar a la resolución del problema. Resaltar que:

... es una cantidad finita de pasos que se llevan a cabo en un tiempo finito (los bucles infinitos no son algoritmos.)

... es una sucesión de pasos no ambiguos, es decir cada paso especifica una tarea determinada a ser realizada en cada momento por el ordenador.

Los pasos a seguir en la resolución de cualquier problema mediante un ordenador son los siguientes: 1. Análisis del problema. 2. Búsqueda del algoritmo. 3. Programación de algoritmo. 4. Traducción y comprobación del programa. Análisis del problema

a.- Acotar y especificar el problema con total precisión (obtener el máximo de información acerca de lo que debemos resolver y las soluciones a determinar.)

b.- Definir los datos iniciales o de partida (que datos necesitamos proporcionar del problema para resolverlo.)

c.- Definir que datos o resultados debe proporcionar el algoritmo. Búsqueda del algoritmo

Búsqueda de una sucesión finita de pasos no ambiguos que nos lleven a la resolución del problema: a.- Selección del mejor algoritmo. b.- Mejora del algoritmo.



La selección y la mejora se hacen, habitualmente, en función del tiempo de ejecución (aproximadamente la cantidad de instrucciones que se tienen que ejecutar para resolver correctamente el problema.)

Ejemplo 1: Búsqueda de números primos entre 2 y un cierto valor MAX 1.- Análisis del problema. ¿Qué es un número primo? ¿Qué entradas tenemos? ¿Qué queremos

obtener como resultado? 2.- Búsqueda del algoritmo.

Método 1 .1. X = 2

.2. I = 2

.3. Hacer ( X/I )

.4. Si I es menor que X y la división es entera entonces X no es primo y pasar a 7

.5. Si I es igual que X entonces X es primo y pasar a 7

.6. Incrementar I y pasar a .3.

.7. Si X es más pequeño que MAX entonces incrementar X y pasar a .2.

Mejora del algoritmo: parar la división si la ‘I’ es mayor que ‘X/2’ Método 2: Criba de Eratóstenes

.1. Poner todos los números entre 2 y MAX uno detrás de otro.

.2. Si hay números sin tachar, el primero de ellos es primo

.3. Tachar de la lista todos los múltiplos del primer número

.4. Borrar el primer número

.5. Borrar los tachados y pasar a .2.

Ejemplo 2: Suma de una sucesión aritmética 1.- Análisis del problema. Descripción del problema: a1 + a2 + a3 + ... + an donde a2 = a1 + d y en

general an = a1 + n*d Entrada: Primer término (a1) Distancia (d) Número de términos (n) Salida: Suma de todos los términos ∑

=

=

n

ini Sa

1

2.- Búsqueda del algoritmo. Método 1 Calcular los términos e ir sumándolos poco a poco:

.1. Sn ← 0

.2. i ← 1

.3. X ← a1

.4. Si i es más grande que n saltar a .9.

.5. Sn ← Sn + X

.6. X ← X + d

.7. i ← i + 1

.8. Volver a .4.

.9. Mostrar el resultado (Sn)



Método 2: Aplicación de la fórmula

.1. dnnanS n ⋅−⋅

+⋅= 2)1(

1

.2. Mostrar el resultado (Sn)

Para la obtención de los algoritmos utilizaremos normalmente dos métodos: Diseño descendente o modular: El problema se divide en subprogramas de más fácil

resolución. Representación gráfica de funciones. La representación como un solo problema es difícil de resolver, sin embargo podemos calcular los cortes con los ejes, máximos, mínimos y puntos de inflexión, asíntotas,... Una vez obtenidos los resultados podemos proceder a juntarlos y obtener la representación gráfica. Diseño por refinamiento por pasos: Se va buscando la solución y se va especificando hasta

llegar a una solución concreta que si que sabemos resolver.

Resolución de la serie de Taylor: ...!4!21)cos(42

+++=xx

x Solución parcial xn Solución parcial n!

Generalmente la utilización de los dos métodos es complementaria. Programación del algoritmo

Una vez determinado el algoritmo hay que escribirlo en un lenguaje de alto nivel. Por eso lo mejor es escribir el algoritmo en un lenguaje restringido que sea fácil de traducir a un lenguaje de alto nivel. Existen dos formas básicas de escribir los algoritmos para conseguir esto: El pseudocódigo y los organigramas (o diagramas de flujo.) El pseudocódigo es una manera de escribir algoritmos de forma poco estricta (con una sintaxis relajada) o estructuras de datos poco detalladas, pero intentando acercar las ideas del algoritmos a estructuras y sintaxis parecidas a las de los lenguajes de alto nivel en los que vamos a programar el algoritmo. Los organigramas o diagramas de flujo son dibujos que representan de manera gráfica tanto las tareas como la sucesión de tareas del algoritmo. Las tareas se representan mediante rectángulos, rombos y romboides y el flujo de tareas mediante flechas que enlazan las diferentes tareas. Las instrucciones se representan en rectángulos:

Las entradas y salidas en romboides:

Las condiciones en rombos:

El inicio, el final y los puntos de reunión de flujo en círculos:

Ejercicios: 1. Calcular la tabla del dos. 2. Calcular el cuadrado de los 10 primeros números. 3. Calcular el factorial de un número.



Tipos de datos simples La acción de un programa consiste en proporcionar un conjunto de datos de salida (resultados) a partir de un conjunto de datos de entrada (valores iniciales). La información en el ordenador se guarda en celdas que sólo pueden estar en dos estados posibles: encendido/apagado. Habitualmente estos estados suelen representarse con números: encendido, uno y apagado cero. De alguna manera en cada celda podemos guardar o bien un cero o bien un uno. Pero normalmente en un ordenador necesitaremos guardar información distinta de ceros y unos (números enteros, reales, etc.). La información básica que podremos guardar en un ordenador va a ser: • Información booleana: El tipo booleano tiene dos valores posibles: verdadero y falso.

Sintaxis: booleano

• Valores enteros (positivos y negativos): almacena números enteros Sintaxis: entero

entero positivo

• Caracteres: almacena un carácter. Sintaxis: caracter

• Valores reales: almacena números reales. Existen dos tipos de números reales: o Números reales de precisión simple: real simple o Números reales de precisión doble: real doble

• Tipo puntero: almacena direcciones de memoria Sintaxis: puntero

• Sin valor:

Variables: son posiciones de memoria donde se guarda datos de un tipo específico y que tienen asociadas un identificador (nombre). Las variables se declaran al principio del algoritmo (programa), y los valores que almacenan se pueden modificar durante la ejecución del programa. Constantes: son aquellos valores fijos que no se pueden alterar durante la ejecución del programa, pueden ser de cualquier tipo (real, entero, booleano). Estructuras de control Llamaremos estructuras de control a las acciones que tienen como objeto marcar el orden de ejecución de las instrucciones y que van a servirnos para escribir concisamente y sin ambigüedades los algoritmos. Todas las estructuras de control que estudiaremos estarán compuestas de unos elementos básicos (léxico) y una estructura (sintaxis.)



Estructuras secuenciales

En una estructura secuencial una instrucción sigue a otra en una secuencia lineal. Pseudocódigo

Inicio tarea1 tarea2 ... tarean Fin

Organigrama

Ejemplo: Producto escalar de dos vectores bidimensionales.

(ax, ay) • (bx, by) = ax*bx + ay*by Pseudocódigo

Inicio Leer (ax) Leer (ay) Leer (bx) Leer (by) prod_esc ← ax*bx + ay*by Escribir (prod_esc) Fin

Organigrama

Estructuras selectivas

Son las que toman una cierta dirección dentro del flujo del programa en función de una condición o el valor de una variable.

Alternativas simples

Se realiza una acción o conjunto de acciones si se cumple una determinada condición. Pseudocódigo

... Si ( condición ) entonces acciones Fin_si ...

Organigrama



Ejemplo: Ordenar dos números (Leídos dos números escribir por pantalla primero el menor y luego el mayor) Pseudocódigo

Inicio Leer (a) Leer (b) Si (a > b) Entonces aux ← a a ← b b ← aux Fin_si Escribir (a) Escribir (b) Fin

Organigrama

Alternativas dobles Si una condición se cumple se realizan unas acciones, si no se cumple la condición se realizan otras.

Pseudocódigo ... Si ( condición ) entonces acciones1 sino acciones2 Fin_si ...

Organigrama

Ejemplo sencillo: Dado un número, decir si es positivo o negativo. Pseudocódigo

Algoritmo Positivo_Negativo Variables x: Entero Inicio Leer (x) Si (x<0) entonces Escribir (‘Numero negativo’) sino Escribir (‘Numero positivo’) Fin_si Fin

Organigrama



Ejemplo: Cálculo de las soluciones de una ecuación de segundo grado.

acabbx

⋅⋅⋅−±−=

242

Pseudocódigo Algoritmo ecuación_segundo_grado Variables a, b, c: entero x1, x2: real discriminante: entero Inicio Leer (a, b, c) Si1 (a = 0) entonces Si2 (b = 0) entonces Si3 (c = 0) entonces Escribir (‘La solución es cualquier valor real’) Sino3 Escribir (‘No existe ningún valor que cumpla la ecuación’) Fin_si3 Sino2 x1 ← -c / b Escribir (x1) Fin_si2 Sino1 discriminante ← b * b - 4 * a * c Si4 (discriminate < 0) entonces Escribir (‘Soluciones complejas’) Sino4 x1 ← (-b + sqrt (discriminante) ) / ( 2 * a) x2 ← (-b + sqrt (discriminante) ) / ( 2 * a) Escribir (x1, x2) Fin_si4 Fin_si1 Fin



Organigrama

Alternativas múltiples

Dependiendo del valor de una variable se realizan unas acciones u otras. Pseudocódigo

...

Según_sea (variable) hacer

Caso valor1: acciones1

Caso valor2: acciones2

…

Caso valorn: accionesn

Default: accionesx

Fin_según_sea

...

Organigrama

Este tipo de estructuras se utiliza especialmente cuando se programan menús de selección. Ejemplo: Calculadora infantil. Realizar un programa que pida dos números y una operación (suma, resta, multiplicación o división) y nos de el resultado de operar los números con esa operación.

Pseudocódigo Algoritmo Calculadora Variables x, y, op: Entero res: Real Inicio Escribir ( ‘Dame números’) Leer (x, y) Escribir (‘Dame operación:’) Escribir (‘(1-Suma/2-Resta’)

Organigrama



Escribir (‘(3-Multiplic./4-División’) Leer (op) Según_sea (op) hacer Caso 1: res a + b Escribir (res) Caso 1: res a + b Escribir (res) Caso 1: res a + b Escribir (res) Caso 1: res a + b Escribir (res)

Default: Escribir (‘Operación no válida’)

Fin_según_sea Fin

Estructuras repetitivas (o bucles)

Un bucle es un conjunto de instrucciones del programa que se ejecutan repetidamente o bien un número determinado de veces, o bien mientras se cumpla una determinada condición (hay que tener cuidado con los bucles infinitos) Todo bucle contiene los siguientes elementos (aunque no necesariamente en ese orden): • Iniciación de las variables referentes al bucle. • Decisión (seguimos con el bucle o terminamos.) • Cuerpo del bucle.

Existen tres tipos de bucles en programación estructurada: Bucle Desde…Hasta

Este bucle se utiliza cuando sabemos el número de veces que queremos que se realice una cierta tarea. Pseudocódigo

...

Desde variable ← v_ini hasta v_fin hacer

acciones

Fin_desde

...

Organigrama



Bucle Hacer…Mientras

Este bucle lo utilizaremos si sabemos la condición que hace que se repita la tarea varias veces. Las acciones se realizan al menos una vez, antes de realizar la comprobación de la condición

Pseudocódigo ...

Hacer

acciones

Mientras (condición)

...

Organigrama

Bucle Mientras…Hacer

Es muy parecido al anterior, pero en este caso la comprobación de la condición se realiza antes de ejecutar la tarea, de manera que la tarea puede no llegar a hacerse.

Pseudocódigo ...

Mientras (condición) Hacer

acciones

Fin_Mientras

...

Organigrama

Bucles anidados e independientes.

Existen dos maneras básicas de utilizar varios bucles: De forma anidada y de forma independiente. De forma independiente nos limitaremos a ir haciendo los bucles de manera que al finalizar uno empezará el siguiente. De esta forma las tareas entre bucles son independientes (cálculo del número combinatorio) Otra forma es mediante la utilización de bucles anidados. Los bucles anidados son bucles que están dentro de otros bucles de manera que la ejecución de los bucles internos depende de la ejecución de los bucles externos (algoritmo que muestre las tablas de multiplicar del 1 al 10.) Programación modular Cuando realizamos ciertos programas (por ejemplo el programa de números combinatorios) podemos darnos cuenta que existen ciertas partes del programa que se repiten de forma muy similar, de manera que cambiando pocos elementos quedarían realmente iguales. Estas partes del programa que se repiten podríamos hacerlas depender de unos valores para que sirviesen para cualquier propósito. A estas partes de los programas es a lo que llamaremos módulos o subprogramas. Con esta separación podemos reutilizar ciertas partes del código de forma más sencilla, y podemos escribir más fácilmente los programas utilizando el diseño descendente para la resolución de algoritmos.



Las características básicas que deben cumplir los subprogramas o módulos son: a.- Realización de una tarea específica. b.- Parametrización para caracterizar la actuación de los módulos (parámetros) c.- Existen básicamente dos tipos distintos de subprogramas: las funciones y los procedimientos

(las funciones devuelven uno o más valores, mientras que los procedimientos devuelven ninguno o más. Sin embargo, el C/C++ no hace tal distinción; para él sólo existen funciones e interpreta los procedimientos como un ejemplo particular de función que no devuelve ningún valor)

Definición de funciones Para crear una función hay que definirla. Dentro de la definición fijamos el nombre de la función, la lista de parámetros/argumentos que le pasamos a la función, el tipo del resultado que devuelve y el cuerpo de la función. Sintaxis:

nombre_funcion (lista_de_parametros) : tipo_del_val or_devuelto

inicio

cuerpo de la funcion

devuelve valor //(tipo indicado en la definición) fin

Notas: • Solo se puede devolver un valor con la sentencia devuelve

• El tipo de la variable que se devuelve ha de coincidir con el tipo_del_valor_devuelto utilizado en la sentencia de definición de la variable.

Prototipos de las funciones En el cuerpo de un programa antes de la definición de las funciones se declaran los prototipos de todas las funciones que forman parte del programa. En la declaración del prototipo se declara el nombre de la función, el tipo de dato que devuelve la función, el número y tipos de los argumentos que se le pasarán a la función. Sintaxis:

nombre_funcion (tipos_lista_de_parametros) : tipo_d el_valor_devuelto

Llamada a las funciones Para usar las funciones que hemos declarado, simplemente hemos de llamar a la función por su nombre, pasándole entre paréntesis tantos valores (argumentos) como parámetros formales hayamos definido. Estos valores que utilizamos en la llamada, se van copiando sobre las variables definidas como parámetros; por lo tanto ha de existir una correspondencia, no sólo entre el número de valores y el número de parámetros, sino también entre sus tipos. Sintaxis:

Variable <- nombre_funcion(lista_de_parametros)



Ámbito de las variables Recordemos que definíamos a las funciones como un subprograma o módulo independiente que realiza una determinada tarea definida en su cuerpo. Estas funciones manejarán datos almacenados en variables, que podrán ser de diferentes clases según el lugar donde estén declaradas:

Variables Locales Se declaran dentro de la función, bien dentro del cuerpo o bien como parámetros formales. Son propias de cada módulo y sólo existe mientras dura la ejecución del módulo. Cuando la ejecución del módulo desaparece, las variables locales desaparecen.

Variables Globales Se declaran fuera del cuerpo de cualquier función y antes de que sea utilizada por ninguna de ellas (se recomienda declararlas al comienzo del programa antes de las definiciones de las funciones). Son variables que existen durante toda la ejecución del algoritmo, de manera que se puede acceder a ellas en cualquier momento de la ejecución del algoritmo, y además son visibles por cualquier función y cualquiera de ellas puede modificar su valor. Paso de parámetros

Los parámetros de una función se pueden definir de dos maneras: por valor o por referencia. Por valor

Este método copia el valor de los argumentos pasados a la función en un espacio de memoria que se reserva para ellos, de manera que los cambios que se realicen sobre el parámetro en el interior de la función no afectan a las variables utilizadas como argumentos en la llamada.

Por referencia Lo que pasamos a la función es una referencia al parámetro que se pasa, es decir, la dirección de memoria donde se encuentra dicha variable; de manera que no existe un espacio reservado para ese parámetro durante la ejecución del módulo. Cualquier modificación que realicemos del parámetro en el interior de la función quedará reflejada en el punto desde el que se hizo la llamada al módulo. En la lista de parámetros que le pasamos a la función hemos de indicar cómo le pasamos dichos parámetros: • Por valor: no indicamos nada (por defecto es el paso que se utiliza). • Por referencia: indicamos con la palabra ref

Sintaxis:

nombre_funcion (tipo par1,tipo ref par2,ref par3,…) :tipo_valor_devuelto

En una misma función podemos utilizar parámetros por valor y parámetros por referencia. Los parámetros definidos por valor son parámetros de entrada de información a la función, mientras que los parámetros definidos por referencia son parámetros de entrada y salida ya que las modificaciones realizadas sobre dichos parámetros dentro de la función quedan reflejadas después de la llamada a ésta. En C/C++ cuando una función ha de devolver más de un valor es normal devolverlos mediante el uso de argumentos de la función pasados por referencia (solo se puede devolver uno con la sentencia devuelve).



Programación estructurada Diremos que estamos realizando una programación estructurada si… …empleamos para el diseño de los algoritmos el diseño descendente y/o modular. …descomponemos, en función del diseño descendente, el programa en módulos independientes

(prohibida la utilización de variables globales.) …en cualquier caso, sólo utilizamos en la escritura de los algoritmos (y los programas) los tres tipos

de estructuras de control vistas. Recurrencias (o recursividad) Es la propiedad de llamar a una función desde sí misma o desde otra que ha sido llamada por ésta. Esto se traduce en que dentro del código de un subprograma hay una sentencia o expresión donde aparece la llamada a la misma función. En matemáticas la recursividad es una forma sencilla y habitual de definir una función a partir de ella misma (por ejemplo la definición de factorial o de los números de Fibonacci.) Para no crear secuencias de infinitas llamadas (ya que la función llamada, volverá a llamarse por ser a su vez recursiva) necesitamos dos elementos:

1. Las funciones recursivas deben tener argumentos, cuyos valores diferencien a una llamada de otra.

2. Debe existir una condición final o condición de parada, que utiliza la información de los argumentos para verificar si la recursión debe finalizar, en cuyo caso no se producen más llamadas.

La recursividad está directamente ligada con una técnica de programación llamada Divide y vencerás, de tal manera que esta técnica nos ayuda a descubrir la forma que debe tener nuestra función recursiva. Esta técnica se basa en lo siguiente: frente a un problema, se realizan una serie de tareas básicas que nos llevan a tener el mismo problema pero de complejidad menor. Si esto lo aplicamos recursivamente, la resolución del problema se traduce en ejecutar una serie de tareas simples que nos desembocan al final en el mismo problema pero de una complejidad tan simple que es trivial resolverlo. Esta resolución se hace en la condición final de la recursión y se denomina Caso Base.

tema 2: algoritmos y programasinformatica.uv.es/mguia/asignatu/inf/2009_10...estructuras de control...

Documents