Embed Size (px)
Citation preview
TEMAS DE EXPOSICION Centro Universitario de la Costa
Ingeniería en Computación
Programación
Alumna:
Yuliana Lizbeth Ruiz Cardenas
P á g i n a 1 | 47
Índice
Lenguaje de programación C .................................................................................. 3
Estructura general básica de un programa en Lenguaje C ..................................... 4
Como insertar comentarios en Lenguaje C ............................................................. 5
Palabras reservadas predefinidas en el Lenguaje C ............................................... 6
Identificadores para variables, constantes y funciones en C ................................... 7
Tipos de Datos en Lenguaje C: Char, Int, Float y Double ....................................... 8
Calificadores de Datos en C: signed, unsigned, short y long ................................ 10
Variables en Lenguaje C - Declaración y ejemplos ............................................... 11
Constantes Lenguaje en C - Directiva #define y ejemplo ...................................... 12
Secuencias de escape en C - Saltos de línea ....................................................... 13
Inclusión de archivos de cabecera - Directiva #include ......................................... 14
Operadores Aritméticos básicos en C - Tipos y ejemplos ..................................... 15
Printf y Scanf - Funciones para imprimir y capturar datos ..................................... 17
Operadores relacionales o de comparación <, >, ==, !=........................................ 19
Operadores condicionales en C - if, else, elseif y switch ....................................... 20
Operadores lógicos y tabla de verdad - AND &&, OR ||, Not ! ............................... 22
Bucles ejemplos y sintaxis - Ciclos While, Do While y For .................................... 23
Variables Locales y Globales en C - Diferencias y ejemplo .................................. 25
Funciones en Lenguaje C - Declaración, sintaxis y ejemplos ............................... 26
Recursividad en el lenguaje C ............................................................................... 28
Arrays, arreglos, cadenas o vectores en C - Ejemplos y uso ................................ 29
Matrices en C - Bidimensional, tridimensional con ejemplo................................... 31
Algoritmos de ordenación y búsqueda .................................................................. 32
Estructuras y Uniones en C - Arrays de estructuras .............................................. 34
Punteros en Lenguaje C - ¿Qué son y cómo usarlos? .......................................... 36
Asignación dinámica de memoria .......................................................................... 37
Cadenas ................................................................................................................ 39
Ficheros - Abrir, cerrar, leer y agregar archivos de texto ...................................... 40
Organización de datos en un archivo .................................................................... 43
Tipos de datos TAD/objetos .................................................................................. 44
P á g i n a 2 | 47
Listas enlazadas .................................................................................................... 45
Asignación dinámica de memoria Malloc. Pilas, colas y listas .............................. 47
P á g i n a 3 | 47
Lenguaje de programación C
Es un Lenguaje de propósito general, desarrollado en 1972 por Dennis Ritchie en
los Laboratorios Bell, es considerado como un lenguaje de alto nivel. La primera
implementación de este la realizó sobre un computador DEC PDP-11 con sistema
operativo UNIX. Podemos decir que el lenguaje C es un lenguaje de nivel medio, ya
que combina elementos de lenguaje de alto nivel con la funcionalidad del lenguaje
ensamblador, esto lo hace un lenguaje potente, con un campo de aplicación
ilimitado y, sobre todo, se aprende rápidamente.
El lenguaje de programación C es un lenguaje de alto nivel que se puede
caracterizar por los siguientes puntos:
• Es de propósito general, esto significa que puede ser usado tanto para el
desarrollo de sistemas operativos como para programas científicos, programas
de aplicación o programas de educación y juegos.
• Posee una alta transportabilidad ya que los programas escritos en C pueden ser
llevados de un tipo de ordenador a otro y funcionarán. Los cambios que hay que
realizar son mínimos.
• Como solo tiene 32 palabras reservadas se dice que es compacto.
• Los compiladores generan ejecutables más pequeños porque por norma
general, los programas escritos en lenguaje C poseen menos líneas de código
que otros lenguajes de programación de alto nivel.
• El lenguaje de programación C es un lenguaje imperativo o procedimental. Esto
significa que indica secuencias de acciones con el fin de llegar a un objetivo.
Generalmente los lenguajes imperativos o procedimentales contienen una parte
declarativa. El lenguaje C da órdenes a la máquina.
• Es un lenguaje estructurado ya que los programas escritos con él se pueden
organizar en módulos.
P á g i n a 4 | 47
Estructura general básica de un programa en Lenguaje C
Un programa escrito en el lenguaje de programación C está formado siempre por
una o más funciones, una de las cuales, obligatoriamente debe ser la que
representa al programa principal y se designa la palabra reservada main, la cual es
la primera que se ejecuta al comenzar el programa, llamándose desde ella al resto
de funciones que compongan nuestro programa. El nombre de una función C
siempre va seguida de paréntesis, tanto si tiene argumentos como si no y debe ir
acompañada de dos llaves ({}) que determinan el principio y el fin del programa.
• La primera línea indica que se tengan en cuenta las funciones y tipos definidos
en la biblioteca stdio (standard input/output).
• En la función main se incluye una primera sentencia que llama a la función
printf. Ésta toma como argumento (encerrado entre paréntesis) una cadena de
caracteres limitados por dobles comillas " " y la imprime en la salida habitual. El
símbolo \n indica un cambio de línea.
• La segunda sentencia, return, termina el programa y devuelve un valor (cero) al
sistema operativo. Si bien no es obligatorio terminar el programa con un return,
es conveniente indicarle a quien lo haya invocado, sea el Sistema Operativo o
algún otro programa, si la finalización ha tenido éxito o no.
• Cada sentencia de programa queda finalizada por el terminador ";", que indica
al compilador el fin de esta. Esto es necesario ya que sentencias complejas
pueden llegar a tener más de un renglón, y habrá que avisar al compilador
donde terminan.
P á g i n a 5 | 47
Como insertar comentarios en Lenguaje C
Un comentario sirve para generar anotaciones al programador en el código fuente
del programa, así como también para desactivar una o más instrucciones. A la hora
de programar es conveniente añadir comentarios para poder saber que función tiene
cada parte del código, en caso de que no lo utilicemos durante algún tiempo. La
inclusión de comentarios en un programa es una saludable práctica, como lo
reconocerá cualquiera que haya tratado de utilizar el código fuente hecho por otro
programador. Para el compilador, los comentarios son inexistentes, por lo que no
generan líneas de código, permitiendo abundar en ellos tanto como se desee.
Existen distintas posibilidades para insertar comentarios en el código C como son:
• Comentarios en bloque: Su finalidad es servir de guía o información para una
mejor comprensión del programa. El bloque de comentario empieza con el
símbolo /* y termina obligatoriamente con el símbolo */. Un bloque puede tener
la extensión que se desee: una línea, dos líneas, cinco, diez, …, n líneas.
• Comentarios en línea: El comentario puede encontrarse en una línea
independiente o bien en una línea después del código existente en la línea. El
comentario empieza con el símbolo // y termina cuando termina la línea, sin que
exista un símbolo específico de terminación.
En un mismo programa pueden aparecer tantos comentarios en bloque o en línea
como se estimen oportunos, si bien lo más habitual es situar los comentarios en
bloque al comienzo de los ficheros o antes de la declaración de una función para
resaltar los aspectos más importantes, mientras que los comentarios en línea suelen
situarse en puntos intermedios del código informando sobre distintas cuestiones de
interés o que merezcan la pena ser aclaradas.
P á g i n a 6 | 47
Palabras reservadas predefinidas en el Lenguaje C
En el lenguaje C, como en cualquier otro lenguaje, existen una serie de palabras
clave que el usuario no puede utilizar como identificadores (nombres de variables
y/o de funciones). Estas palabras sirven para indicar al computador que realice una
tarea muy determinada (desde evaluar una comparación, hasta definir el tipo de una
variable) y tienen un especial significado para el compilador. Todas las palabras
reservadas son con minúsculas (este lenguaje es sensitivo al uso de mayúsculas y
minúsculas).
El C es un lenguaje muy conciso, con muchas menos palabras clave que otros
lenguajes. A continuación, se presenta una tabla con las 32 palabras clave del ANSI
C (algunos compiladores añaden otras palabras clave, propias de cada uno de ellos,
es importante evitarlas como identificadores):
auto break case char const continue default do
double else enum extern float for goto if
int long register return short signed sizeof static
struct switch typedef union insigned void volatile while
P á g i n a 7 | 47
Identificadores para variables, constantes y funciones en
C
Es necesario resaltar que C es un lenguaje sensible al contexto por lo que diferencia
entre mayúsculas y minúsculas, y, por tanto, diferencia entre una palabra escrita
total o parcialmente en mayúsculas y otra escrita completamente en minúsculas.
En el lenguaje C, un identificador es el nombre que damos a las variables y
funciones que no sea una palabra reservada que comience por una letra o por un
subrayado, pudiendo contener en su interior letras, números y subrayados. Por el
contrario, no acepta los acentos ni la ñ/Ñ y el primer carácter de un identificador no
puede ser un número. La longitud máxima de un identificador depende del
compilador que se esté usando, pero, generalmente, suelen ser de 32 caracteres,
ignorándose todos aquellos caracteres que compongan el identificador y
sobrepasen la longitud máxima.
A continuación, vemos algunos ejemplos de identificadores válidos y no válidos:
Para crear un identificador, especifíquelo en la declaración de una variable, un tipo
o una función. Una vez declarado, puede utilizar el identificador en instrucciones de
programa posteriores para hacer referencia al valor asociado.
En este ejemplo, result es un identificador para una variable de tipo entero:
P á g i n a 8 | 47
Tipos de Datos en Lenguaje C: Char, Int, Float y Double
El tipo de dato de la variable nos indica el conjunto de valores que puede tomar, su
ocupación en la memoria RAM y las operaciones que pueden realizarse con ella:
Para hacer uso de variables debemos declararlas previamente con algún tipo de
dato. Para definir variables en C se antepone la palabra reservada al identificador
de la variable. Se pueden definir las variables sin asignarles ningún valor. Si
tenemos varios datos que son del mismo tipo, se pueden definir todas en la misma
línea de código escribiendo una sola vez el tipo de dato, separando el nombre de
las variables por “,”. Una vez que se haya acabado de definir variables, se cierra la
línea de código con “;”.
En C existen básicamente cuatro tipos de datos:
• Tipo entero: representa números enteros con o sin signo, que estarán
compuestos por los dígitos del 0 al 9. Por ejemplo: 0, 23, -176, -1, etc. Para
definir datos enteros se antepone la palabra reservada int al identificador de la
variable:
• Tipo real: se emplea para representar números reales (con decimales). Se
definen con “float” o “double”. La diferencia entre ambas es la precisión que
ofrece su representación interna. Hay un número infinito de reales, pero se
representan con un número finito de bits. A mayor número de bits, mayor
número de reales se representan, y, por tanto, mayor precisión. Los reales
definidos con “double” tienen un tamaño doble a los definidos con “float”. Para
P á g i n a 9 | 47
definir datos reales se antepone la palabra reservada float o double al
identificador de la variable:
• Tipo carácter: este tipo de datos se emplea para representar un carácter
perteneciente a un determinado código utilizado por el ordenador (normalmente
el código ASCII). Para representar este tipo de dato se antepone la palabra
reservada char al identificador de la variable:
Un constante tipo char se representa como un solo carácter encerrado entre
comillas simples:
P á g i n a 10 | 47
Calificadores de Datos en C: signed, unsigned, short y
long
Los calificadores de tipo son las palabras clave que describen semánticas
adicionales sobre un tipo. Son una parte integral de las firmas de tipo. Los
calificadores de tipo tienen la misión de modificar el rango de valores de un
determinado tipo de variable. Estos calificadores son cuatro:
• Signed: le indica a la variable que va a llevar signo. Es el utilizado por defecto.
• Unsigned: le indica a la variable que no va a llevar signo (sin valores negativos).
• Short: rango de valores en formato corto (limitado). Es el utilizado por defecto.
• Long: rango de valores en formato largo (ampliado).
P á g i n a 11 | 47
Variables en Lenguaje C - Declaración y ejemplos
Una variable en C es un espacio que reservamos en memoria para poder guardar
información, se utilizan a menudo para guardar números, caracteres, entre otros
tipos de datos, no solo en C si no en cualquier lenguaje de programación, y dicha
información se representa por medio de un tipo de dato especifico, que determina
como la interpretará el lenguaje en sí. Su contenido podrá ser modificado a lo largo
del programa. Una variable sólo puede pertenecer a un tipo de dato. Para poder
utilizar una variable, primero tiene que ser declarada:
Es posible inicializar y declarar más de una variable del mismo tipo en la misma
sentencia:
¿Dónde se declaran las variables?
Las variables pueden ser de dos tipos según el lugar en que las declaremos:
• La variable global se declara antes de la main(). Puede ser utilizada en cualquier
parte del programa y se destruye al finalizar éste.
• La variable local se declara después de la main(), en la función en que vaya a
ser utilizada. Sólo existe dentro de la función en que se declara y se destruye al
finalizar dicha función
Ejemplo:
P á g i n a 12 | 47
Constantes Lenguaje en C - Directiva #define y ejemplo
Hasta ahora habíamos visto cómo definir constantes con una sintaxis del tipo const
int nombre = 10 pero existe otra manera de crear constantes en C basada en la
directiva #define, esto significa que esa constante tendrá el mismo valor a lo largo
de todo el programa y no puede ser modificado de ninguna manera. En
programación es una buena práctica escribir los identificadores de las constantes
en mayúsculas, de esta forma es más fácil localizarlos en el código de un programa.
Para indicar al compilador que se trata de una constante, usaremos la directiva
#define:
Nótese que, después de la declaración de una constante simbólica no se escribe un
carácter punto y coma (;), cosa que sí se debe hacer al declarar una variable.
Ejemplo:
P á g i n a 13 | 47
Secuencias de escape en C - Saltos de línea
Cuando estamos escribiendo un programa puede que necesitemos representar la
información de una forma especial, con ciertas alineaciones, tabulaciones o estilos,
en C es posible realizar estas tareas mediante las llamadas secuencias de escape.
Las combinaciones de caracteres que consisten en una barra invertida (\) seguida
de una letra o una combinación de dígitos se denominan "secuencias de escape".
Hay 33 símbolos que no se visualizan en la pantalla, esto es debido a que son del
tipo No Imprimibles y su papel es el de realizar una acción concreta o insertar un
carácter que no es posible visualizarlo. En C, todas las secuencias de escape
constan de dos o más caracteres, el primero de los cuales es la barra invertida
(\). Los caracteres restantes determinan la interpretación de la secuencia de
escape.
Tabla de las secuencias de escape
más significativas
Ejemplo
P á g i n a 14 | 47
Inclusión de archivos de cabecera - Directiva #include
En el lenguaje C es posible utilizar funciones que no estén incluidas en el propio
programa. Para ello utilizamos la directiva #include, que nos permite añadir librerías
o funciones que se encuentran en otros ficheros a nuestro programa.
Se denomina header file, al español fichero/archivo (de) cabecera, o include file, al
español fichero de inclusión al archivo, normalmente en forma de código fuente, que
el compilador incluye de forma automática al procesar algún otro archivo fuente. Un
header file contiene, normalmente, una declaración directa de clases, subrutinas,
variables, u otros identificadores. Para incluir un archivo de cabecera se debe usar
#Include.
Típicamente los programadores especifican la inclusión de los header files por
medio de pragmas al comienzo (head o cabecera) de otro archivo fuente, aquellos
que desean declarar identificadores estándares en más de un archivo fuente pueden
colocar esos identificadores en un único header file, que se incluirá cuando el código
que contiene sea requerido por otros archivos.
Para indicar al compilador que vamos a incluir ficheros externos podemos hacerlo
de dos maneras (siempre antes de las declaraciones):
1. Indicándole al compilador la ruta donde se encuentra el fichero.
2. Indicando que se encuentran en el directorio por defecto del compilador.
P á g i n a 15 | 47
Operadores Aritméticos básicos en C - Tipos y ejemplos
Operadores aritméticos
Existen dos tipos de operadores aritméticos:
• Operadores binarios:
Son aquellos operadores aritméticos que permiten realizar cálculos con valores
numéricos para obtener un resultado. Los más habituales son la suma, resta,
multiplicación y división, además disponemos de un operador adicional al que
denominamos operador módulo (%), que nos permite obtener el resto de una
división entre enteros.
La sintaxis es la siguiente: <variable1><operador><variable2>
• Operadores unarios:
Los operadores aritméticos de incremento y decremento son los únicos
operadores, además de los que involucran asignación, que tienen efectos
colaterales e incrementan o decrementan la variable en una unidad.
La sintaxis es la siguiente: <variable><operador> o <operador><variable>
Operadores de asignación
Un operador de asignación altera el valor de un objeto sin alterar su tipo. El operador
usual de asignación (=), copia el valor del operando de la derecha en el operando
de la izquierda, aplicando las conversiones de tipo usuales cuando es necesario.
La mayoría de los operadores aritméticos binarios explicados en el capítulo anterior
tienen su correspondiente operador de asignación:
P á g i n a 16 | 47
Jerarquía de operaciones
La jerarquía de operadores determina el orden en el que se resuelven las
expresiones cuando se involucran operaciones aritméticas como la suma, resta,
multiplicación, división, potencia, raíz y módulo de la división. Si en una operación
encontramos signos del mismo nivel de precedencia, dicha operación se realiza de
izquierda a derecha. Este orden es el que permite que una expresión aritmética
cualquiera siempre tenga la misma interpretación ya sea resolviéndola en papel, en
calculadora o en el computador.
P á g i n a 17 | 47
Printf y Scanf - Funciones para imprimir y capturar datos
Salida de datos (Sentencia / función Printf)
Una funcionalidad básica del lenguaje en C es la de mostrar mensajes por pantalla.
La salida de datos por pantalla más básica la conseguimos a través de la función
printf, esta nos permitirá mostrar mensajes al usuario del programa, visualizar el
resultado de cálculos, etc. Se puede introducir la cantidad de texto y la cantidad de
variables a mostrar por pantalla que se desee. La sintaxis básica para esta función
es la siguiente: printf(control, arg1, arg2...);
También podemos introducir una cadena de texto (sin necesidad de argumentos),
o combinar ambas posibilidades, así como secuencias de escape. En el caso de
que utilicemos argumentos deberemos indicar en la cadena de control tantos
modificadores como argumentos vayamos a presentar.
El modificador está compuesto por el carácter % seguido por un carácter de
conversión, que indica de qué tipo de dato se trata.
P á g i n a 18 | 47
Entrada de datos (Sentencia / función Scanf)
Mediante la función scanf podemos introducir cualquier combinación de valores
numéricos, caracteres sueltos y cadenas de caracteres a través del teclado. En
definitiva, scanf lee datos en distintos formatos de la entrada estándar. La función
devolverá el número de datos que se han introducido correctamente. La sintaxis
básica es la siguiente: scanf("%Modificador", &nombreVariable);
La principal característica es que necesita saber la posición de la memoria del
ordenador en que se encuentra la variable para poder almacenar la información
obtenida. Para indicarle esta posición utilizaremos el símbolo (&), que colocaremos
delante del nombre de cada variable. (Esto no será necesario en los arrays).
P á g i n a 19 | 47
Operadores relacionales o de comparación <, >, ==, !=
Se llaman operadores relacionales o de comparación a aquellos que permiten
comprobar si una relación especifica entre dos valores es verdadera. El resultado
de una expresión relacional es 1 si la relación probada es true y 0 si es false.
Este resultado se usa a menudo para afectar el flujo de control (a través
de if, while, for), pero también se puede almacenar en variables.
Los operadores de comparación o relacionales básicos en C son:
Si hay más de un operador se evalúan de izquierda a derecha. Además, los
operadores == y != están por debajo del resto en cuanto al orden de precedencia.
P á g i n a 20 | 47
Operadores condicionales en C - if, else, elseif y switch
El lenguaje C dispone de varias estructuras de control para modificar el flujo
secuencial de la ejecución: fundamentalmente las sentencias if y switch
implementan las bifurcaciones, que permiten elegir entre dos o más opciones según
ciertas condiciones y dependiendo del resultado seleccionan la instrucción a
ejecutar.
Estructura if – else
La sentencia if nos permite elegir si se ejecuta o no un bloque de instrucciones.
La sintaxis básica es la siguiente:
• if(condición) sentencia;
• if(condición){ bloque;
}
Donde bloque representa un bloque de instrucciones.
Una sentencia if, cuando incluye la cláusula else, permite ejecutar un bloque de
código si se cumple la condición y otro bloque de código diferente si la condición no
se cumple. La sintaxis básica es la siguiente:
• if(condición) sentencia1;
else sentencia2;
• if(condición){ bloque1;
} else{ bloque2; } Los bloques de código especificados representan dos alternativas complementarias
y excluyentes.
P á g i n a 21 | 47
La sentencia if-else pueden encadenarse haciendo que se evalúe un conjunto de
condiciones y se ejecute una sola de las opciones entre varias.
Estructura Switch
Esta estructura permite seleccionar entre varias alternativas posibles de manera que
según la opción seleccionada se ejecuten una serie de sentencias. La sintaxis
básica es la siguiente:
• switch(variable){ case contenido_variable1: sentencias; break; case contenido_variable2: sentencias; break; default: sentencias;
} Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves, ya
que se ejecutan todas hasta que se encuentra la sentencia break. La variable
evaluada sólo puede ser de tipo entero o carácter. Default ejecutará las sentencias
que incluya, en caso de que la opción escogida no exista.
P á g i n a 22 | 47
Operadores lógicos y tabla de verdad - AND &&, OR ||,
Not !
Los operadores lógicos pueden crear condiciones compuestas en una fórmula,
como que se deben cumplir dos o más condiciones para elegir un determinado
método de cálculo. Este tipo de operadores permite obtener solo dos resultados
(Verdadero o Falso). Las expresiones conectadas con los operadores se evalúan
de izquierda a derecha y la evaluación se detiene cuando el resultado es verdadero
o falso.
Los operadores lógicos básicos son tres:
Tabla de verdad
Ejemplo:
P á g i n a 23 | 47
Bucles ejemplos y sintaxis - Ciclos While, Do While y For
Son estructuras de repetición que ejecutan un bloque de sentencias mientras se
cumpla una expresión lógica (condición que puede ser simple o compuesta de otras
condiciones unidas por operadores lógicos). Este bloque de sentencias que se
ejecuta repetidas veces, se denomina bucle, y cada ejecución se denomina
iteración. Las estructuras de control repetitivas utilizan dos tipos de variables:
Contadores y Acumuladores.
Sentencia / Bucle While
Permite la ejecución de un bloque de sentencias si se evalúa como verdadera una
expresión lógica que siempre aparece al principio del bloque de sentencias. Si ésta
no se cumple, el programa no entrará en el bucle. Su sintaxis es la siguiente:
• while (expresión lógica) sentencia;
• while(expresión lógica){ bloque de sentencias;
} Se lee de la siguiente forma: Mientras la evaluación de la expresión lógica sea
verdadera realice la secuencia de acciones.
Sentencia / Bucle Do...While
La sentencia es ejecutada repetidamente mientras la condición resulte verdadera.
Si no se especifica condición se asume que es "true", y el bucle se ejecutará
indefinidamente. A diferencia del bucle "while", la evaluación se realiza después de
ejecutar la sentencia, de modo que se ejecutará al menos una vez .
Su sintaxis es la siguiente:
• do{ sentencia1; sentencia2;
}while(expresión lógica) Se lee de la siguiente forma: Haga la secuencia de acciones mientras la expresión
lógica sea verdadera.
P á g i n a 24 | 47
Sentencia / Bucle For
La sentencia es ejecutada repetidamente hasta que la evaluación de la condición
resulte falsa. Su principal característica radica en el hecho de que dentro de sí
misma, constan la inicialización de variables, así como también las variables de
incremento/decremento, necesarias en un ciclo. Antes de la primera iteración se
ejecutará la iniciación del bucle, que puede ser una expresión lógica. Después de
cada iteración se ejecutará el incremento de las variables del bucle.
Su sintaxis es la siguiente:
• for(inicialización;condicion;incremento){ sentencia1; sentencia2;
} Se lee de la siguiente forma: Para la variable que empieza en valor_inicial, hasta
que llegue al valor_final, incrementándose o decrementándose en el valor de "paso"
haga la secuencia de acciones.
Sentencias de control break y continue
Permiten modificar y controlar la ejecución de los bucles anteriormente descritos:
• La sentencia break provoca la salida del bucle en el cual se encuentra y la
ejecución de la sentencia que se encuentra a continuación del bucle.
• La sentencia continue provoca que el programa vaya directamente a comprobar
la condición del bucle en los bucles while y do/while, o bien, que ejecute el
incremento y después compruebe la condición en el caso del bucle for.
P á g i n a 25 | 47
Variables Locales y Globales en C - Diferencias y ejemplo
Según el lugar donde son declaradas puede haber dos tipos de variables:
• Variable global: es aquella que se define fuera del cuerpo de cualquier función,
normalmente al principio del programa, después de la definición de los archivos
de biblioteca (#include), de la definición de constantes simbólicas y antes de
cualquier función. El ámbito de una variable global son todas las funciones que
componen el programa, cualquier función puede acceder a dichas variables
para leer y escribir en ellas. Es decir, puede ser utilizada en cualquier parte del
programa y se destruye al finalizar este. Las variables globales existen
permanentemente y retienen sus valores aun después de que las funciones que
las setean han terminado su ejecución, deben ser definidas exactamente una
vez, fuera de todas las funciones, esto les asigna almacenamiento.
• Variable local: es aquella cuyo ámbito se restringe a la función que la ha
declarado se dice entonces que la variable es local a esa función. Esto implica
que esa variable sólo va a poder ser manipulada en esa sección, y no se podrá
hacer referencia fuera de dicha sección. Cuando una variable x es local a una
función func1, significa que la función func1 es la propietaria de dicha variable,
y puede acceder a ella y modificarla. Si cualquier otra función del programa
necesita conocer el valor de la variable x, es la función func1 la que debe
transferir el valor de x a través del paso de argumentos en la llamada a la
función. Dos variables locales pueden tener el mismo nombre siempre que
estén declaradas en funciones diferentes.
Si dos variables, una global y una local, tienen el mismo nombre, la local prevalecerá
sobre la global dentro de la función en que ha sido declarada.
P á g i n a 26 | 47
Funciones en Lenguaje C - Declaración, sintaxis y
ejemplos En C, se conocen como funciones aquellos trozos de códigos utilizados para dividir
un programa con el objetivo que, cada bloque realice una tarea determinada. Las
funciones que define el programador son conocidas como funciones de usuario.
La sintaxis de una función es la siguiente:
• tipo_funcion nombre_funcion (tipo y nombre de argumentos){ bloque de sentencias;
} donde:
• Tipo_funcion: Es el tipo de dato que devolverá esa función, que puede ser
real, entera, o tipo void (es decir que no devolverá ningún valor).
• Nombre_ funcion: Es el identificador que le damos a nuestra función.
• Tipo y nombre de argumentos: son los parámetros que recibe la función.
Los argumentos de una función no son más que variables locales que reciben
un valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden
existir funciones que no reciban argumentos.
• Bloque de sentencias: Constituye el conjunto de acciones, de sentencias
que cumplirá la función, cuando sea ejecutada. Entre ellas están:
1. Asignaciones
2. Lecturas
3. Impresiones
4. Cálculos, etc.
Una función, termina con la llave de cerrar, pero antes de esta llave, debemos
colocarle la instrucción return, con la cual devolverá un valor específico. Si la función
es tipo void, no tiene que ir la sentencia return, ya que de lo contrario, nos dará un
error. Nunca se debe llamar a la función main desde otro lugar del programa.
Declaración de una función
Antes de empezar a utilizar una función se debe declarar. La declaración de una
función se conoce también como prototipo de la función. En este se tienen que
especificar los parámetros de la función, así como el tipo de dato que devuelve.
P á g i n a 27 | 47
Los prototipos de las funciones son utilizados por el compilador para verificar que
se accede a la función de la manera adecuada con respecto al número y tipo de
parámetros, y al tipo de valor de retorno de esta. Los prototipos de las funciones
pueden escribirse antes de la función main o bien en otro fichero. En este último
caso se lo indicaremos al compilador mediante la directiva #include.
Paso de parámetros a una función
Las funciones pueden retornar un valor, esto se hace mediante la instrucción return,
que finaliza la ejecución de la función, devolviendo o no un valor. En una misma
función podemos tener más de una instrucción return. La forma de retornar un valor
es la siguiente:
• return(valor o expresión);
El valor devuelto por la función debe asignarse a una variable. De lo contrario, el
valor se perderá.
P á g i n a 28 | 47
Recursividad en el lenguaje C
En C, las funciones pueden llamarse a sí mismas. Si una expresión en el cuerpo de
una función llama a la propia función, se dice que ésta es recursiva.
Cuando la función se llama a sí misma, se asigna un espacio en la pila para las
nuevas variables locales y parámetros, y el código de la función se ejecuta con estas
nuevas variables desde el principio. Una llamada recursiva no hace una nueva copia
de la función. Sólo son nuevos los argumentos. Al volver de una llamada recursiva
se recuperan de la pila las variables locales y los parámetros antiguos, y la ejecución
se reanuda en el punto de la llamada a la función dentro de la función.
La principal ventaja de las funciones recursivas es que se pueden usar para crear
versiones de algoritmo más claras y sencillas.
Ejemplo:
P á g i n a 29 | 47
Arrays, arreglos, cadenas o vectores en C - Ejemplos y uso
Un array (arreglo), es una variable estructurada que permite almacenar un conjunto
de datos del mismo tipo de forma consecutiva en memoria. A los datos almacenados
en un array se les denomina elementos; al número de elementos de un array se les
denomina tamaño o rango del vector. Para acceder a los elementos individuales de
un array se emplea un índice que será un número entero no negativo que indicará
la posición del elemento dentro del array.
Vectores
Un vector es un array unidimensional, es decir, sólo utiliza un índice para referenciar
a cada uno de los elementos. Su sintaxis basica es la siguiente:
• tipo nombre [tamaño];
donde:
• tipo: Tipo de dato que tiene el conjunto de variables: int, float, char, etc.
• nombre: Identificador con el nombre del array.
• tamaño: Cantidad de espacios de memoria que queremos reservar.
Podemos inicializar (asignarle valores) un vector en el momento de declararlo. Sus
sintaxis son las siguientes:
• tipo nombre [tamaño] = {varlor1, valor2, …}
El numero de valores entre llaves tiene que ser menor o igual al tamaño. Si es
menor el resto de los valores se quedan sin inicializar.
• tipo nombre [ ] = {valor1, valor2, …}
Si no se especifica el tamaño se reservarán tantos espacios como elementos
haya entre llaves.
P á g i n a 30 | 47
Una particularidad con los vectores de tipo char (cadena de caracteres) es que
termina con el carácter especial ‘\0’ (cero). En resumen, al declarar una cadena
deberemos reservar una posición más que la longitud que queremos que tenga
dicha cadena.
Llamadas a funciones con arrays
Un aspecto para tener muy en cuenta es que C no permite el paso de un array por
valor a una función, un array es siempre pasado por "referencia", pues en la llamada,
lo que se pasa es la dirección del primer elemento del array (recuérdese que el
nombre de un array es un puntero al primer elemento).
P á g i n a 31 | 47
Matrices en C - Bidimensional, tridimensional con ejemplo
Una matriz es un vector de vectores o un también llamado array bidimensional. Las
matrices en C se almacenan al igual que los vectores en posiciones consecutivas
de memoria. Usualmente uno se hace la idea que una matriz es como un tablero,
pero internamente el manejo es como su definición lo indica, un vector de vectores,
es decir, los vectores están uno detrás del otro juntos.
La manera de declarar una matriz en C es similar a un vector excepto que se
requiere un índice por cada dimensión. Su sintaxis es la siguiente:
• tipo nombre [tamaño 1][tamaño 2]...;
Una matriz bidimensional se podría representar gráficamente como una tabla con
filas y columnas.
La matriz tridimensional se utiliza, por ejemplo, para trabajos gráficos con objetos
3D.
Si al declarar una matriz también queremos inicializarla, habrá que tener en cuenta
el orden en el que los valores son asignados a los elementos de la matriz.
Ejemplo:
P á g i n a 32 | 47
Algoritmos de ordenación y búsqueda Ahora nos centraremos en algunos de los problemas más comunes que surgen en
la computación, los de búsqueda y ordenamiento.
Algoritmos de ordenación
Nos permiten ordenar información de una manera especial basándonos en un
criterio de ordenamiento. El objetivo de este proceso generalmente es facilitar la
búsqueda de uno o más elementos pertenecientes a un conjunto. Los más usados
son:
• Ordenamiento Burbuja: es un algoritmo que se aplica para poder ordenar un
array de datos enteros ya sea de forma ascendente o descendente.
• Ordenamiento por inserción (Insertion Sort): El algoritmo consiste en
ordenar los dos primeros elementos del array, luego se inserta el tercer
elemento en la posición correcta con respecto a los dos primeros ya clasificados
y así sucesivamente hasta llegar al último elemento del array.
• Ordenamiento rápido (Quick Sort): El algoritmo se basa en dividir los n
elementos de la lista a ordenar en dos particiones separadas por un elemento:
una partición izquierda, un elemento central (pivote o elemento de partición), y
una partición derecha. La partición se hace de tal forma que todos los elementos
de la primera sublista (partición izquierda) son menores que todos los elementos
de la segunda sublista (partición derecha). Las dos sublistas se ordenan
entonces independientemente.
En conclusión, se suele recomendar que para listas pequeñas los métodos más
eficientes son burbuja y selección; y para listas grandes, el Quicksort.
Algoritmos de búsqueda
La búsqueda de un elemento dentro de un array es una de las operaciones más
importantes en el procesamiento de la información, y permite la recuperación de
datos previamente almacenados. Todos los algoritmos de búsqueda tienen dos
finalidades:
1. Determinar si el elemento buscado se encuentra en el conjunto en el que se
busca.
2. Si el elemento está en el conjunto, hallar la posición en la que se encuentra.
P á g i n a 33 | 47
Los más usados son:
• Búsqueda secuencial o lineal: el algoritmo busca un elemento del array
utilizando un valor destino llamado clave comparando los elementos de forma
secuencial, uno después de otro, hasta que lo encuentra o bien hasta que se
determina que no se encuentra. Funciona bien con arreglos pequeños y con los
no ordenados.
• Búsqueda binaria: este algoritmo consiste en dividir paulatinamente el array
por su elemento medio en dos subarrays más pequeños, y comparar el
elemento con el del centro. Si coinciden, la búsqueda se termina pero si al final
de la búsqueda todavía no lo hemos encontrado, y el subarray a dividir está
vacío, el elemento no se encuentra en el array.
P á g i n a 34 | 47
Estructuras y Uniones en C - Arrays de estructuras
Una estructura es un conjunto de una o más variables, de distinto tipo, agrupadas
bajo un mismo nombre para que su manejo sea más sencillo. Esta capacidad de C
es una característica importante para la creación de programas potentes, tales como
bases de datos u otras aplicaciones que requieran grandes cantidades de datos. La
sintaxis de su declaración es la siguiente:
• struct tipo_estructura { tipo_variable nombre_variable1; tipo_variable nombre_variable2; tipo_variable nombre_variable3;
}; donde:
• tipo_estructura: es el nombre del nuevo tipo de dato que hemos creado.
• tipo_variable y nombre_variable: son las variables que forman parte de la
estructura.
Para definir variables del tipo que acabamos de crear lo podemos hacer de varias
maneras, aunque las dos más utilizadas son éstas:
La forma de acceder a estos campos es la siguiente:
• variable.campo;
donde:
• variable: es el nombre de la variable de tipo estructura que hemos creado.
• campo: es el nombre de la variable que forma parte de la estructura.
Declaramos la estructura, y en el
momento en que necesitamos las
variables, las declaramos.
Las declaramos al mismo tiempo
que la estructura.
P á g i n a 35 | 47
Es posible pasar el contenido de una estructura a otra, siempre que sean del mismo
tipo naturalmente, también inicializar variables de tipo estructura en el momento de
su declaración (si uno de los campos de la estructura es un array de números, los
valores de la inicialización deberán ir entre llaves).
Estructuras y funciones
Las estructuras pueden ser pasadas a funciones pasando miembros de estructura
individuales o pasando toda la estructura. Cuando se pasan estructuras o miembros
individuales de estructura a una función se pasan por llamada por valor. Para pasar
una estructura en llamada por referencia tenemos que colocar el ’*’ o ’&’.
Arrays de estructuras
Se puede crear un array de estructuras tal como se crea un array de otros tipos.
Permiten almacenar juntos diversos valores de diferentes tipos, agrupados como
estructuras. Son idóneos para almacenar un archivo completo de empleados, un
archivo de inventario, etc.
P á g i n a 36 | 47
Punteros en Lenguaje C - ¿Qué son y cómo usarlos? Un puntero es una variable que representa la posición (más que el valor) de otro
dato, tal como una variable o un elemento de un array. Se usan para pasar
información entre una función y puntos de llamada. Permiten código más compacto
y eficiente; utilizándolos en forma ordenada dan gran flexibilidad a la programación.
Declaración de Punteros
Su sintaxis es la siguiente:
• tipo *nombre;
Donde nombre es, naturalmente, el nombre de la variable, y tipo es el tipo del
elemento cuya dirección almacena el puntero.
Operadores
Existen dos operadores especiales para trabajar con punteros:
• & - operador dirección: me da la dirección de un objeto en la memoria. Sólo
sirve para posiciones de memoria (puede apuntar a variables o a vectores, pero
no a constantes o expresiones).
• * - operador indirección: me da el contenido de una posición de memoria
(generalmente almacenada en un puntero).
Los operadores * y & son unarios y tienen más prioridad a la hora de evaluarlos que
los operadores binarios.
Los punteros se asignan igual que el resto de las variables. Es posible desplazar un
puntero recorriendo posiciones de memoria. Para ello podemos usar los operadores
de suma, resta, incremento y decremento.
P á g i n a 37 | 47
Asignación dinámica de memoria
Una ventaja de la utilización de punteros es la posibilidad de realizar una asignación
dinámica de memoria. Esto significa que la reserva de memoria se realiza
dinámicamente en tiempo de ejecución, no siendo necesario entonces tener que
especificar en la declaración de variables la cantidad de memoria que se va a
requerir. En C, se asigna memoria en el momento de la ejecución en el montículo
o montón (heap), mediante las funciones malloc(), realloc(), calloc() y free(), que
asignan y liberan memoria de una zona denominada almacén libre:
• Función malloc(): La función asigna un bloque de memoria que es el numero
de bytes pasados como argumentos. Malloc() devuelve un puntero, que es la
dirección del bloque asignado de memoria. El puntero se utiliza para referencias
el bloque de memoria y devuelve un puntero del tipo void *.
Sintaxis de llamada a la función malloc() es:
• tipo *puntero;
puntero = (tipo *)malloc(tamaño en bytes);
• Función free(): Cuando se ha terminado de utilizar un bloque de memoria
previamente asignado por malloc(), u otras funciones de asignación, se puede
liberar el espacio de memoria y dejarlo disponible para otros usos, mediante
una llamada a la función free(). El bloque de memoria suprimido se devuelve al
espacio de almacenamiento libre, de modo que habrá más memoria disponible
para asignar a otros bloques de memoria. El formato de llamada es:
• free(puntero);
Hay otras funciones que permiten obtener memoria libre en tiempo de ejecución,
estas son calloc() y realloc(). Con ambas se puede asignar memoria, lo que cambia
en relación con la función malloc es la forma de trasmitir el numero de bytes de
memoria requeridos. Ambas devuelven un puntero tipo void * al bloque asignado de
memoria. El puntero se utiliza para referenciar el bloque de memoria.
• Función calloc(): Esta declarada en el archivo de cabecera stdlib.h, por lo que
será necesario incluir ese archivo de cabecera en todo programa que llame a la
función. Se puede reservar memoria dinámicamente para cualquier tipo de dato,
incluyendo char , float, arrays, estructuras e identificadores de typedef.
P á g i n a 38 | 47
Sintaxis de llamada a la función malloc() es:
• tipo *puntero;
puntero = (tipo *) calloc (numero_elementos, tamaño de cada elemento);
El tamaño de cada elemento se expresa en bytes, se utiliza para obtenerlo el
operador sizeof.
• Función realloc(): Esta función también es para asignar un bloque de memoria
libre pero tiene una variación con respecto a las otras, permite ampliar un bloque
de memoria reservado anteriormente.
Sintaxis de llamada a la función realloc() es:
• tipo *puntero;
puntero = (tipo *) realloc (puntero a bloque, tamaño total nuevo bloque);
El puntero hace referencia a un bloque de memoria reservado previamente con
malloc(), calloc() o la propia realloc().
P á g i n a 39 | 47
Cadenas El lenguaje C no dispone de un tipo de dato String para trabajar con cadenas de
texto como en otros lenguajes. Una cadena en C es un array de caracteres de una
dimensión (vector de caracteres) que termina con el carácter especial ‘\0’ (cero).
Podemos conocer la longitud de un array de caracteres usando la función sizeof,
siendo la sintaxis para emplear: sizeof (nombreDelArray).
El formato para declarar una cadena es:
• char nombre[n];
En el caso especial de los arrays de caracteres, podemos utilizar varias formas de
inicialización:
sin especificar el tamaño de la cadena, o especificando el tamaño:
Librería string.h
A través de la librería string.h podemos usar distintas funciones relacionadas con
cadenas. Para usar estas funciones debemos escribir #include <string.h> en
cabecera de nuestro programa. A continuación relacionamos algunas de las
funciones disponibles.
P á g i n a 40 | 47
Ficheros - Abrir, cerrar, leer y agregar archivos de texto
Los ficheros son estructuras de datos almacenadas en memoria secundaria. Para
para guardar o recuperar información de un fichero es necesario realizar una serie
de operaciones que describiremos en este apartado.
Apertura de archivos
Fopen()
Antes de abrir un fichero necesitamos declarar un puntero de tipo FILE, con el que
trabajaremos durante todo el proceso. Para abrir el fichero utilizaremos la función
fopen( ).Su sintaxis es:
• FILE *puntero;
puntero = fopen (nombre del fichero, "modo de apertura");
Donde puntero es la variable de tipo FILE, nombre del fichero es el nombre que
daremos al fichero que queremos crear o abrir. Este nombre debe ir encerrado entre
comillas. Un archivo puede ser abierto en dos modos diferentes:
Modo texto
Modo binario
Freopen()
Esta función cierra el fichero apuntado por el puntero y reasigna este puntero a un
fichero que será abierto. Su sintaxis es:
• freopen (nombre del fichero, "modo de apertura", puntero);
P á g i n a 41 | 47
Donde nombre del fichero es el nombre del nuevo fichero que queremos abrir, luego
el modo de apertura, y finalmente el puntero que va a ser reasignado.
Cierre de archivos
Una vez que hemos acabado nuestro trabajo con un fichero es recomendable
cerrarlo. Los ficheros se cierran al finalizar el programa pero el número de estos que
pueden estar abiertos es limitado. Para cerrar los ficheros utilizaremos la función
fclose( ); cuyo puntero le indicamos como parámetro. Si el fichero se cierra con éxito
devuelve 0 cierra el fichero. Su sintaxis es la siguiente:
• fclose(puntero);
Escritura y lectura de archivos
En C existen muchas y variadas operaciones para leer y escribir en un fichero; entre
ellas tenemos: fread - fwrite, fgetc - fputc, fgets - fputs, fscanf - fprintf, es aconsejable
utilizarlas por parejas.
Lectura y escritura de bloques ( fread – fwrite )
Para leer y escribir en ficheros que no sean de texto las operaciones que se deben
utilizar son fread y fwrite.
El formato de escritura en bloque es el siguiente:
• fwrite (direcc_dato, tamaño_dato, numero_datos, punt_fichero);
La sentencia de lectura de bloque es la siguiente:
• fread (direcc_dato, tamaño_dato, numero_datos, punt_fichero);
Lectura y escritura formateada de texto ( fscanf – fprintf )
Para que lo escrito con fprintf pueda ser correctamente leído con fscanf es
conveniente que el formato en el que se indican los tipos de datos que se van a leer
o escribir sean similares para ambas instrucciones, que los tipos de datos estén
separados, por ejemplo, por un blanco y que tengan un fin de línea al final.
P á g i n a 42 | 47
Lectura y escritura de caracteres ( fgetc – fputc ) y cadenas ( fgets – fputs )
Los formatos de las instrucciones de lectura y escritura de caracteres y cadenas
son:
• carácter_leido = fgetc (fichero);
fgetc lee un carácter del fichero, el carácter leído se almacenará en carácter leído.
Cuando se llega al final del fichero devuelve EOF.
• fputc (car, fichero);
fputc escribe el carácter car en el fichero. Devuelve el carácter escrito o EOF en
caso de error.
• fgets (cadena_leida, num_caracteres, fichero);
Lee num_caracteres del fichero y los almacena en cadena_leida colocando el
carácter de fin de cadena '\0' en la posición num_caracteres de la cadena leída.
P á g i n a 43 | 47
Organización de datos en un archivo
Las estructuras de datos aplicadas a colección de datos en almacenamiento
secundario se llaman organización de archivos
La organización de un archivo define la forma en que los registros se disponen sobre
el soporte de almacenamiento, o también se define la organización como la forma
en que se estructuran los datos en un archivo. En general se consideran tres
organizaciones fundamentales:
• Organización secuencial: es una sucesión de registros almacenados en forma
consecutiva sobre un soporte externo. Los registros están ubicados físicamente
en una secuencia usualmente fijada por uno o más campos de control
contenidos dentro de cada registro, en forma ascendente o descendente.
• Organización directa o aleatoria (random): los datos se colocan y se acceden
aleatoriamente mediante su posición, es decir, indicando el lugar relativo que
ocupan dentro del conjunto de posiciones posibles. En esta organización se
pueden leer y escribir registros, en cualquier orden y en cualquier lugar.
• Organización secuencial indexada: Un archivo con esta organización consta
de tres áreas:
-Área de índices: es una tabla que contiene los niveles de índice, la existencia
de varios índices enlazados se denomina nivel de indexación.
-Área primaria: contiene los registros en forma secuencial y esta organizada en
secuencia de claves sin dejar huecos intercalados.
-Área de excedentes (overflow): utilizada, si fuese necesario, para las
actualizaciones.
P á g i n a 44 | 47
Tipos de datos TAD/objetos
Un tipo abstracto de datos (TAD) es una colección de propiedades y de operaciones
que se definen mediante una especificación que es independiente de cualquier
representación. La abstracción se centra en la independencia de la representación.
Esto permite al programador modificar la representación del TAD sin que esto afecte
a su utilización. Se suele considerar que un tipo abstracto de datos es un tipo de
datos construido por el programador para resolver una determinada situación.
Una de las principales ventajas de los TADs es que permite construir programas
modularizados y estructurados, ya que las tareas lógicas para un tipo se encapsulan
en un módulo independiente, que se compila independientemente y cuya
representación, como se ha dicho, puede variar sin que afecte al programa que los
utiliza siempre y cuando no se modifique la interfaz.
Los TAD tienen, por lo tanto, dos partes:
• Especificación: Refleja qué hace el tipo. Es necesaria para que el programador
sepa cómo debe implementar el TAD. Suele coincidir con la interfaz, pero no es
necesario que esto ocurra, ya que la interfaz es un concepto de programación por
lo que puede añadir operaciones a la especificación (siempre que tengan
justificación).
• Implementación: La implementación a su vez se compone de una interfaz pública,
que permite al programador utilizar el TAD, y una implementación que puede variar
siempre y cuando la interfaz se mantenga.
P á g i n a 45 | 47
Listas enlazadas
Es una de las estructuras de datos fundamentales, y puede ser usada para
implementar otras estructuras de datos. Consiste en una secuencia de nodos, en
los que se guardan campos de datos arbitrarios y una o dos referencias, enlaces
o punteros al nodo anterior o posterior. El principal beneficio de las listas enlazadas
respecto a los vectores convencionales es que el orden de los elementos enlazados
puede ser diferente al orden de almacenamiento en la memoria o el disco,
permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento.
Las listas enlazadas permiten inserciones y eliminación de nodos en cualquier punto
de la lista en tiempo constante (suponiendo que dicho punto está previamente
identificado o localizado), pero no permiten un acceso aleatorio.
Tipos De Listas
1. Lista simplemente enlazada: Cada nodo, contiene un único apuntador hacia el
siguiente nodo, por lo cual hace de él una estructura muy eficiente, ya que el
último de la lista apunta hacia null, por ello, es fácil hacer recorridos directos.
2. Listas Doblemente enlazadas: Esta lista se caracteriza por que sus nodos
contienen dos punteros, uno hacia el nodo siguiente y otro hacia el nodo
anterior.
3. Listas Circulares: Este tipo de lista, es sólo una extensión de la lista
simplemente enlazada, con la diferencia que el último elemento se enlaza al
primer elemento de la lista, lo cual permite el recorrido en forma de anillo
4. Lista Circular Doblemente enlazada: Quizá este tipo de lista sea la más
compleja, ya que es la combinación de la lista circular y las doblemente
enlazadas, ya que es una lista doblemente enlazada donde el primer elemento
se conecta con el último y viceversa.
Operaciones con las listas
• P: puntero a un nodo.
• L: puntero a la lista.
• ListaVacia(L): Iniciliza la lista L, como lista vacía.
• empty(L): determina si la lista está vacía o no.
P á g i n a 46 | 47
• Insertar(L, x, p): Inserta al dato x, en un nuevo nodo de la lista L, después del
nodo apuntado por p.
• eliminar(L, x): elimina, de la lista L, el nodo que contiene a x.
• Nodo(p): Hace referencia al nodo que apunta p.
• Info(p): hace referencia al info del nodo.
• next(p): siguiente dirección si p no es NULL
• Info(next(p)): info del nodo que sigue a nodo (p) en la lista
P á g i n a 47 | 47
Asignación dinámica de memoria Malloc. Pilas, colas y
listas Estructuras dinámicas de datos
En función de la forma en que se relacionan existen varios tipos de estructuras de
datos. Este tipo de estructuras son autorreferenciadas, es decir, contienen entre sus
campos un puntero de su mismo tipo. Las más utilizadas son:
• Pilas: Este tipo de estructuras se caracteriza porque todas las operaciones se realizan
en el mismo lado. Es de tipo LIFO (Last In First Out), el último elemento en entrar es el
primero en salir. La estructura tipo que utilizaremos será ésta:
• Colas: Este tipo de estructuras se caracteriza porque insertamos los elementos
por un lado y los extraemos por el otro lado. Es de tipo FIFO (First In First Out),
el primer elemento en entrar es el primero en salir. La estructura que
utilizaremos será:
• Listas: Este tipo de estructuras se caracteriza porque los elementos están
enlazados entre sí, de manera que además de las acciones habituales de
insertar, extraer y visualizar también podremos buscar un elemento. La
estructura que utilizaremos será:
