Professional Documents
Culture Documents
ESTRUCTURAS SECUENCIALES
Son problemas en los que, para su solución se emplea una serie de acciones ejecutadas
invariablemente en un orden secuencial.
Las tareas suceden de tal modo que la salida de una es la entrada de la siguiente y así
sucesivamente hasta el fin del proceso.
Dentro de este tipo podemos encontrar operaciones de inicio/fin, inicialización de variables,
operaciones de asignación, cálculo, sumarización, etc.
Este tipo de estructura se basa en las 5 fases de que consta todo algoritmo o programa:
Definición de variables (Declaración)
Inicialización de variables.
Lectura de datos
Cálculos
Salida
REPRESENTACIÓN GRÁFICA.
ESTRUCTURAS SELECTIVAS
Una decisión es la estructura según la cual se puede escoger uno de entre dos caminos
lógicos dependiendo de una condición que al ser evaluada nos brinda la oportunidad de
saber cuál de los dos caminos escoger. La evaluación de dicha condición siempre va a
originar una respuesta VERDADERA (cuando la condición se cumple) o FALSA (cuando
dicha condición no se cumple) y con ello se podrá saber cuál es el conjunto de instrucciones
a resolver. La representación de una estructura selectiva se hace con palabras en
pseudocódigo (if – then – else o en español si – entonces - sino) y en flujograma con una
figura geométrica en forma de rombo.
La condición, en algoritmos técnicos, se podrá expresar en términos de dos tipos de
operadores: los operadores relacionales y los operadores booleanos. Recordemos que los
operadores relacionales son aquellos que nos originan una respuesta Verdadera o Falsa y
que corresponden a los símbolos mayor que, menor que, mayor o igual, menor o igual, igual
(de comparación) y diferente de. Los operadores booleanos son aquellos que nos permiten
establecer conexiones entre expresiones en donde aparezcan los operadores booleanos y
corresponden a los operadores:
AND: Genera Verdadero si todas las expresiones relacionales conectadas son Verdaderas
OR: Genera Verdadero si al menos una de las expresiones conectadas es Verdadera
NOT que invierte el sentido lógico de la expresión
Con estos elementos podemos recordar que la utilización de las decisiones como estructura
básica de programación no tiene ninguna restricción y que pueden considerarse como
válidos los siguientes casos:
Una decisión dentro de otra
Una decisión a continuación de otra
Muchas decisiones dentro de otras
Muchas decisiones a continuación de otras
Los lenguajes de programación normalmente cuentan con una forma de seleccionar uno de
entre varios caminos lógicos que correspondería a una pequeña modificación de la
estructura de DECISIÓN pero que en últimas partes del mismo supuesto.
ESTRRUCTURAS SELECTIVAS SIMPLES
Se identifican porque están compuestos únicamente de una condición.
La estructura si – entonces evalúa la condición y en tal caso:
Si la condición es verdadera, entonces ejecuta la acción Si (o acciones si son varias).
Si la condición es falsa, entonces no se hace nada.
Representación gráfica:
DONDE:
Condición: Expresa la condición o conjunto de condiciones a evaluar
Acción: Expresa la operación o conjunto de operaciones que se van a realizar si la condición
resulta verdadera.
REPRESENTACIÓN GRÁFICA:
DONDE:
Condición: Expresa la condición o conjunto de condiciones a evaluar
Acción 1: Expresa la operación o conjunto de operaciones que se van a realizar
si la condición resulta verdadera.
Acción 2: Expresa la operación o conjunto de operaciones que se van a realizar
si la condición resulta falsa
REPRESENTACIÓN PSEUDOCODIFICADA.
Español Inglés
Si <condición> entonces If <condición> then
<acción S1> <acción S1>
sino else
<acción S2> <acción S2>
Fin_Si End_if
En este caso se constituye en una selección de dos posibilidades. Si la condición es
verdadera se ejecuta la acción 1, y si es falsa, se ejecuta la acción 2. En el Flujograma es
recomendable que el camino verdadero deba colocarse a la derecha y lo falso a la izquierda.
En el diagrama N-S no se puede cambiar el orden del Si y No.
ESTRUCTURAS SELECTIVAS MULTIPLES
Con frecuencia es necesario que existan más de dos elecciones posibles. Este problema
se podría resolver por estructuras selectivas simples o dobles, anidadas o en cascada, pero
si el número de alternativas es grande puede plantear serios problemas de escritura y de
legibilidad.
Usando la estructura de decisión múltiple se evaluará una expresión que podrá tomar n
valores distintos, 1, 2 , 3, ...., n y según que elija uno de estos valores en la condición, se
realizará una de las n acciones o lo que es igual, el flujo del algoritmo seguirá sólo un
determinado camino entre los n posibles.
Esta estructura se representa por un selector el cual si toma el valor 1 ejecutará la acción
1, si toma el valor 2 ejecutará la acción 2, si toma el valor N realizará la acción N.
Así, si el selector toma el valor 1 se ejecutará la acción 1, si toma el valor 2 se ejecutará la
acción 2, si toma el valor N, se realizará la acción N. De otra forma, si no es ningún caso
de los anteriores, significa que no se cumplió ninguna de las anteriores, entonces se
realizará la acción X.
Deberá reemplazar Selector por variables, propiedad o expresión que vaya a ser el valor
clave.
Estructuras de Control Iterativas repetir mientras, hasta, desde.
En la vida diaria existen situaciones que frecuentemente se resuelven realizando una
determinada secuencia de pasos que puede repetirse muchas veces, ejemplo:
El proceso que seguimos para comer, mientras no se termine la comida.
El proceso de insertar monedas, hasta que se abone la cantidad necesaria.
Las operaciones que realizamos para llamar por teléfono, mientras no se logre la
comunicación.
Como se puede observar estos son algoritmos que se hacen cotidianamente, pero tienen
la particularidad de que la ejecución de alguno de sus pasos puede repetirse muchas veces,
mientras no se logre la meta trazada. A este tipo de algoritmo se le conoce como algoritmos
iterativos o repetitivos. En C#, las instrucciones while, do/while, y for, permiten ejecutar
iteraciones, bucles o ciclos. En cada caso se ejecuta un bloque de instrucciones mientras
la condición que se evalúa tome valor verdadero. Se resalta que cualquiera de las 3
instrucciones cumple con el mismo objetivo que es el de ejecutar una secuencia de pasos,
más de una vez.
La instrucción while
La instrucción while tiene la siguiente sintaxis:
La semántica de la instrucción es la siguiente:
<condición>. Está representada por una expresión booleana y mientras se cumpla se
ejecutará el ciclo.
[Bloque de Instrucciones] El bloque de instrucciones puede estar formado por una o varias
instrucciones y es el conjunto de pasos que se van ejecutar en cada iteración del ciclo.
Para una mayor comprensión se muestra su representación en un diagrama de actividad.
MCD()
Para implementar la responsabilidad de la clase de calcular el Máximo Común Divisor MCD
se utilizará el algoritmo de Euclides que consiste en:
P1: Si los números son iguales, tomar el primer número como respuesta y concluir la
ejecución del algoritmo, en otro caso pasar al paso 2.
P2: Determinar cuál de los dos números es mayor.
P3: Sustituir el número mayor por la diferencia entre los números mayor y menor.
P4: Pasar al paso 1.
Obsérvese como se repiten los pasos 1,2 y 3 y el paso 4 consiste precisamente en regresar
al paso 1, esta repetición se conoce normalmente con el nombre de iteración, nótese que
esta no es infinita, precisamente en el primer paso se especifica que los pasos siguientes
(2, 3, 4) han de ejecutarse si no cumple la condición de que los números sean iguales. Esta
condición es una expresión booleana.
Ejecutar el algoritmo para un par de valores (8 y 20 por ejemplo)
Para implementar el método que permita calcular el máximo común divisor utilizaremos la
estructura de control while se evaluará la condición de que los números sean diferentes y
en dependencia del resultado de la misma se ejecutarán o no los pasos que forman parte
del ciclo. El método MCD, quedaría de la siguiente manera:
CantDigitos()
Para determinar la cantidad de dígitos que tiene el número, primeramente se divide el
número entre 10, si el cociente de la división es 0, se toma 1 como respuesta, sino, se toma
dicho cociente y se divide entre 10, este proceso se estará repitiendo mientras el nuevo
cociente sea distinto de 0. Como se observa, al menos se necesita realizar una división, por
lo que la estructura do/while es la indicada para implementar este algoritmo. Para
implementar el método hay que tener en cuenta lo siguiente:
P1: Se realiza la división del número entre 10.
P2: Se almacena el cociente en una variable y se cuenta que número de división es.
P3: Si el resultado del cociente es distinto de 0, se repite el paso 1.
El método quedaría de la siguiente manera:
ARREGLOS:
Un arreglo puede definirse como un grupo o una colección finita, homogénea y ordenada
de elementos. Los arreglos pueden ser de los siguientes tipos:
De una dimensión.
De dos dimensiones.
De tres o más dimensiones.
Tipos de arreglos
Arreglos unidimensionales.
Arreglos multidimensionales.
Arreglo con múltiple subíndices.
Arreglos unidimensionales
Es un tipo de datos estructurado que está formado de una colección finita y ordenada de
datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales.
Están formados por un conjunto de elementos de un mismo tipo de datos que se almacenan
bajo un mismo nombre, y se diferencian por la posición que tiene cada elemento dentro del
arreglo de datos. Al declarar un arreglo, se debe inicializar sus elementos antes de
utilizarlos. Para declarar un arreglo tiene que indicar su tipo, un nombre único y la cantidad
de elementos que va a contener.
Arreglos multidimensionales
Es un tipo de dato estructurado, que está compuesto por dimensiones. Para hacer
referencia a cada componente del arreglo es necesario utilizar n índices, uno para cada
dimensión. El término dimensión representa el número de índices utilizados para referirse
a un elemento particular en el arreglo. Los arreglos de más de una dimensión se llaman
arreglos multidimensionales.
Arreglos con múltiple subíndices
Es la representación de tablas de valores, consistiendo de información arreglada en
renglones y columnas. Para identificar un elemento particular de la tabla, deberemos de
especificar dos subíndices; el primero identifica el renglón del elemento y el segundo
identifica la columna del elemento. A los arreglos que requieren dos subíndices para
identificar un elemento en particular se conocen como arreglo de doble subíndice. Note que
los arreglos de múltiples subíndices pueden tener más de dos subíndices. El estándar ANSI
indica que un sistema ANSI C debe soportar por lo menos 12 subíndices de arreglo.
Operaciones con arreglos
Las operaciones en arreglos pueden clasificarse de la siguiente forma:
Lectura: este proceso consiste en leer un dato de un arreglo y asignar un valor a cada uno
de sus componentes
Escritura: Consiste en asignarle un valor a cada elemento del arreglo.
Asignación: No es posible asignar directamente un valor a todo el arreglo
Actualización: Dentro de esta operación se encuentran las operaciones de eliminar, insertar
y modificar datos. Para realizar este tipo de operaciones se debe tomar en cuenta si el
arreglo está o no ordenado.
Ordenación.
Búsqueda.
Insertar.
Borrar.
Modificar.
Ordenaciones en Arreglos
La importancia de mantener nuestros arreglos ordenados radica en que es mucho más
rápido tener acceso a un dato en un arreglo ordenado que en uno desordenado.
Existen muchos algoritmos para la ordenación de elementos en arreglos, algunos de ellos
son:
Selección directa
Este método consiste en seleccionar el elemento más pequeño de nuestra lista para
colocarlo al inicio y así excluirlo de la lista. Para ahorrar espacio, siempre que vayamos a
colocar un elemento en su posición correcta lo intercambiaremos por aquel que la esté
ocupando en ese momento.
Ordenación por burbuja
Es el método de ordenación más utilizado por su fácil comprensión y programación, pero
es importante señalar que es el más ineficiente de todos los métodos. Este método consiste
en llevar los elementos menores a la izquierda del arreglo ó los mayores a la derecha del
mismo. La idea básica del algoritmo es comparar pares de elementos adyacentes e
intercambiarlos entre sí hasta que todos se encuentren ordenados.
Ordenación por mezcla
Este algoritmo consiste en partir el arreglo por la mitad, ordenar la mitad izquierda, ordenar
la mitad derecha y mezclar las dos mitades ordenadas en un array ordenado. Este último
paso consiste en ir comparando pares sucesivos de elementos (uno de cada mitad) y
poniendo el valor más pequeño en el siguiente hueco.
Algoritmos de búsqueda que existen
Búsquedas en Arreglos: Una búsqueda es el proceso mediante el cual podemos localizar
un elemento con un valor especifico dentro de un conjunto de datos. Terminamos con éxito
la búsqueda cuando el elemento es encontrado.
Búsqueda secuencial: A este método también se le conoce como búsqueda lineal y consiste
en empezar al inicio del conjunto de elementos , e ir a través de ellos hasta encontrar el
elemento indicado ó hasta llegar al final de arreglo. Este es el método de búsqueda más
lento, pero si nuestro arreglo se encuentra completamente desordenado es el único que
nos podrá ayudar a encontrar el dato que buscamos.
Búsqueda binaria: Las condiciones que debe cumplir el arreglo para poder usar búsqueda
binaria son que el arreglo este ordenado y que se conozca el numero de elementos. Este
método consiste en lo siguiente: comparar el elemento buscado con el elemento situado en
la mitad del arreglo, si tenemos suerte y los dos valores coinciden, en ese momento la
búsqueda termina. Pero como existe un alto porcentaje de que esto no ocurra, repetiremos
los pasos anteriores en la mitad inferior del arreglo si el elemento que buscamos resulto
menor que el de la mitad del arreglo, o en la mitad superior si el elemento buscado fue
mayor. La búsqueda termina cuando encontramos el elemento o cuando el tamaño del
arreglo a examinar sea cero.
Búsqueda por hash: La idea principal de este método consiste en aplicar una función que
traduce el valor del elemento buscado en un rango de direcciones relativas. Una desventaja
importante de este método es que puede ocasionar colisiones
ARCHIVOS
Todos los datos que un programa utiliza durante su ejecución se encuentran en sus
variables, que están almacenadas en la memoria RAM del computador.
La memoria RAM es un medio de almacenamiento volátil: cuando el programa termina, o
cuando el computador se apaga, todos los datos se pierden para siempre.
Para que un programa pueda guardar datos de manera permanente, es necesario utilizar
un medio de almacenamiento persistente, de los cuales el más importante es el disco duro.
Los datos en el disco duro están organizados en archivos. Un archivo es una secuencia de
datos almacenados en un medio persistente que están disponibles para ser utilizados por
un programa. Todos los archivos tienen un nombre y una ubicación dentro del sistema de
archivos del sistema operativo.
Lectura de archivos
Para leer datos de un archivo, hay que abrirlo de la siguiente manera:
archivo = open(nombre)
nombre es un string que tiene el nombre del archivo. archivo es el archivo lógico a través
del que se manipulará el archivo.
Si el archivo no existe, ocurrirá un error de entrada y salida (IOError).
Es importante recordar que la variable archivo es una representación abstracta del archivo,
y no los contenidos del mismo.
La manera más simple de leer el contenido es hacerlo línea por línea. Para esto, basta con
poner el archivo lógico en un ciclo for:
for linea in archivo:
# hacer algo
Una vez que los datos han sido leídos del archivo, hay que cerrarlo:
archivo. Lose()
Por ejemplo, supongamos que tenemos el archivo himno.txt que tiene el siguiente
contenido:
Puro Chile
es tu cielo azulado
puras brisas
te cruzan también.
El archivo tiene cuatro líneas. Cada línea termina con un salto de línea (\n), que indica que
a continuación comienza una línea nueva.
El siguiente programa imprime la primera letra de cada línea del himno:
archivo = open('himno.txt')
for linea in archivo:
print linea[0]
archivo.close()
El ciclo for es ejecutado cuatro veces, una por cada línea del archivo. La salida del programa
es:
P
e
p
t
Otro ejemplo: el siguiente programa imprime cuántos símbolos hay en cada línea:
archivo = open('himno.txt')
for linea in archivo:
print len(linea)
archivo.close()
La salida es:
11
20
13
19
Note que el salto de línea (el “enter”) es considerado en la cuenta:
+---+---+---+---+---+---+---+---+---+---+---+
| P | u | r | o | | C | h | i | l | e | \n| = 11 símbolos
+---+---+---+---+---+---+---+---+---+---+---+
Para obtener el string sin el salto de línea, se puede usar el método strip, que elimina todos
los símbolos de espaciado al principio y al final del string:
>>> s = ' Hola\n'
>>> s.strip()
'Hola'
Si modificamos el programa para eliminar el salto de línea:
archivo = open('himno.txt')
for linea in archivo:
print len(linea.strip())
archivo.close()
entonces la salida es:
10
19
12
18
Lo importante es comprender que los archivos son leídos línea por línea usando el ciclo for.
Escritura en archivos
Los ejemplos anteriores suponen que el archivo por leer existe, y está listo para ser abierto
y leído. Ahora veremos cómo crear los archivos y cómo escribir datos en ellos, para que
otro programa después pueda abrirlos y leerlos.
Uno puede crear un archivo vacío abriéndolo de la siguiente manera:
archivo = open(nombre, 'w')
El segundo parámetro de la función open indica el uso que se le dará al archivo. 'w' significa
«escribir» (write en inglés).
Si el archivo señalado no existe, entonces será creado. Si ya existe, entonces será
sobreescrito. Hay que tener cuidado entonces, pues esta operación elimina los datos del
archivo que existía previamente.
Una vez abierto el archivo, uno puede escribir datos en él usando el método write:
a = open('prueba.txt', 'w')
a.write('Hola ')
a.write('mundo.')
a.close()
Una vez ejecutado este programa, el archivo prueba.txt será creado (o sobreescrito, si ya
existía). Al abrirlo en el Bloc de Notas, veremos este contenido:
Hola mundo.
Para escribir varias líneas en el archivo, es necesario agregar explícitamente los saltos de
línea en cada string que sea escrito. Por ejemplo, para crear el archivo himno.txt que
usamos más arriba, podemos hacerlo así:
a = open('himno.txt', 'w')
a.write('Puro Chile\n')
a.write('es tu cielo azulado\n')
a.write('puras brisas\n')
a.write('te cruzan también.\n')
a.close()
Además del modo 'w' (write), también existe el modo 'a' (append), que permite escribir
datos al final de un archivo existente. Por ejemplo, el siguiente programa abre el
archivo prueba.txt que creamos más arriba, y agrega más texto al final de él:
a = open('prueba.txt', 'a')
a.write('\n')
a.write('Chao ')
a.write('pescao.')
a.close()
Si abrimos el archivo prueba.txt en el Bloc de Notas, veremos esto:
Hola mundo.
Chao pescao.
De haber abierto el archivo en modo 'w' en vez de 'a', el contenido anterior (la
frase Hola mundo) se habría borrado.
Archivos de valores con separadores
Una manera usual de almacenar datos con estructura de tabla en un archivo es la siguiente:
cada línea del archivo representa una fila de la tabla, y los datos de una fila se ponen
separados por algún símbolo especial.
Por ejemplo, supongamos que queremos guardar en un archivo los datos de esta tabla:
Yayita Vinagre 39 49 58 55