1) TEORIA DE PILAS Y COLAS:

-DEFINICION DE PILAS:

Una pila es una estructura de datos de acceso restrictivo a sus elementos. Se puede entender como una pila de libros que se amontonan de abajo hacia arriba. En principio no hay libros; después ponemos uno, y otro encima de éste, y así sucesivamente. Posteriormente los solemos retirar empezando desde la cima de la pila de libros, es decir, desde el último que pusimos, y terminaríamos por retirar el primero que pusimos, posiblemente ya cubierto de polvo.

Es una estructura de tipo LIFO (Last In First Out), es decir, último en entrar, primero en salir.

-OTRA DEFINICION:

Una pila es una lista en que tanto las inserciones como las supresiones se hacen por el mismo extremo, que se conoce como el tope de la pila.

EJEMPLO:

-DEFINICION DE COLAS:

Una cola es una estructura de datos de acceso restrictivo a sus elementos. Un ejemplo sencillo es la cola del cine o del autobús, el primero que llegue será el primero en entrar, y afortunadamente en un sistema informático no se cuela nadie salvo que el programador lo diga.

Es una estructura de tipo FIFO (First In First Out), es decir: primero en entrar, primero en salir.

-OTRA DEFINICION:

Es una lista de proceso restringido en la cual las inserciones se hacen por un extremo llamado "último" y las eliminaciones se hacen por el otro extremo llamado "delantero". Por ejemplo, los aviones que esperan despegar de un aeropuerto forman una cola, el que llega a la pista queda de último y el que va a despegar está de delantero en la cola.

EJEMPLO:

2) FUNCIONES Y USOS DE LAS PILAS Y COLAS:

-FUNCIONES Y USOS DE LAS PILAS:

A) Se emplea en compiladores y editores de texto dirigidos por la sintaxis.

-Permiten comprobar fácil y eficientemente que los símbolos cuyo uso solo tiene sentido por parejas (llaves, paréntesis, etc.) estén adecuadamente balanceados.

B) También se emplea para la evaluación de expresiones.

-Las expresiones escritas en notación convencional (infija, 7 * 2 + 8) pueden convertirse en notación postfija (7 2 * 8 +) mediante una pila.

-Las expresiones escritas en notación postfija pueden calcularse mediante una pila.

-Una función muy importante de las pilas es la implementación en el código compilado de las llamadas a función realizadas en el código fuente.

-También se emplean para transformar un algoritmo recursivo en otro iterativo equivalente.

-FUNCIONES Y USOS DE LAS COLAS:

A) Se emplea en las operaciones sobre las estructuras de datos de otros TADs por ejemplo:

-Recorrido “por niveles” de los nodo de un árbol.

-Recorrido “primero en anchura” de los nodos de un grafo.

-Obtención “de un orden topológico” de los nodos de un grafo aciclico.

B) Algunos servicios de un sistema operativo también se basan en el TAD cola por ejemplo:

-Servicio de Impresión: Los documentos enviados a una impresora se sitúan en una “ cola de impresión” hasta que pueden ser impresos. Las peticiones de impresión se gestionan casi como una cola (orden de llegada, salvo cancelaciones.)

-Planificador: Diferentes estrategias de planificación de procesos (round robin, prioridades, etc.) emplean colas para los procesos que se van a ejecutar y determinar en que orden.

-También se emplean en algoritmos de simulación para problemas de teorías de colas.

3) OPERACIONES DE LAS PILAS Y DE LAS COLAS:

-OPERACIONES DE LAS PILAS:

Operaciones básicas con pilas:

Las pilas tienen un conjunto de operaciones muy limitado, sólo permiten las operaciones de "push" y "pop":

-Push: Añadir un elemento al final de la pila.

-Pop: Leer y eliminar un elemento del final de la pila.

-Push, insertar elemento:

Las operaciones con pilas son muy simples, no hay casos especiales, salvo que la pila esté vacía.

-Push en una pila vacía:

Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a él, además el puntero a la pila valdrá NULL:

El proceso es muy simple, bastará con que:

1. nodo->siguiente apunte a NULL. 2. Pilaa apunte a nodo.

Push en una pila no vacía:

Podemos considerar el caso anterior como un caso particular de éste, la única diferencia es que podemos y debemos trabajar con una pila vacía como con una pila normal.

De nuevo partiremos de un nodo a insertar, con un puntero que apunte a él, y de una pila, en este caso no vacía:

El proceso sigue siendo muy sencillo:

1. Hacemos que nodo->siguiente apunte a Pila. 2. Hacemos que Pila apunte a nodo.

-Pop, leer y eliminar un elemento:

Ahora sólo existe un caso posible, ya que sólo podemos leer desde un extremo de la pila.

Partiremos de una pila con uno o más nodos, y usaremos un puntero auxiliar, nodo:

1. Hacemos que nodo apunte al primer elemento de la pila, es decir a Pila. 2. Asignamos a Pila la dirección del segundo nodo de la pila: Pila->siguiente. 3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda

que la operación pop equivale a leer y borrar. 4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.

Si la pila sólo tiene un nodo, el proceso sigue siendo válido, ya que el valor de Pila->siguiente es NULL, y después de eliminar el último nodo la pila quedará vacía, y el valor de Pila será NULL.

-OPERACIONES DE LAS COLAS:

-Operaciones básicas con colas:

De nuevo nos encontramos ante una estructura con muy pocas operaciones disponibles. Las colas sólo permiten añadir y leer elementos:

Añadir: Inserta un elemento al final de la cola. Leer: Lee y elimina un elemento del principio de la cola.

- Añadir un elemento:

Las operaciones con colas son muy sencillas, prácticamente no hay casos especiales, salvo que la cola esté vacía.

-Añadir elemento en una cola vacía:

Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a él, además los punteros que definen la cola, primero y ultimo que valdrán NULL:

El proceso es muy simple, bastará con que:

1. nodo->siguiente apunte a NULL. 2. Y que los punteros primero y último apunten a nodo.

Añadir elemento en una cola no vacía:

De nuevo partiremos de un nodo a insertar, con un puntero que apunte a él, y de una cola, en este caso, al no estar vacía, los punteros primero y último no serán nulos:

El proceso sigue siendo muy sencillo:

1. Hacemos que nodo->siguiente apunte a NULL. 2. Después que ultimo->siguiente apunte a nodo. 3. Y actualizamos último, haciendo que apunte a nodo.

Añadir elemento en una cola, caso general:

Para generalizar el caso anterior, sólo necesitamos añadir una operación:

1. Hacemos que nodo->siguiente apunte a NULL. 2. Si ultimo no es NULL, hacemos que ultimo->siguiente apunte a nodo. 3. Y actualizamos último, haciendo que apunte a nodo. 4. Si primero es NULL, significa que la cola estaba vacía, así que haremos

que primero apunte también a nodo.

-Leer un elemento de una cola, implica eliminarlo:

Ahora también existen dos casos, que la cola tenga un solo elemento o que tenga más de uno.

-Leer un elemento en una cola con más de un elemento:

Usaremos un puntero a un nodo auxiliar:

1. Hacemos que nodo apunte al primer elemento de la cola, es decir a primero.

2. Asignamos a primero la dirección del segundo nodo de la pila: primero->siguiente.

3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operación de lectura en colas implican también borrar.

4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.

Leer un elemento en una cola con un solo elemento:

También necesitamos un puntero a un nodo auxiliar:

1. Hacemos que nodo apunte al primer elemento de la pila, es decir a primero. 2. Asignamos NULL a primero, que es la dirección del segundo nodo teórico

de la cola: primero->siguiente. 3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda

que la operación de lectura en colas implican también borrar. 4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar. 5. Hacemos que ultimo apunte a NULL, ya que la lectura ha dejado la cola

vacía.

Leer un elemento en una cola caso general:

1. Hacemos que nodo apunte al primer elemento de la pila, es decir a primero. 2. Asignamos a primero la dirección del segundo nodo de la pila: primero-

>siguiente. 3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda

que la operación de lectura en colas implican también borrar. 4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar. 5. Si primero es NULL, hacemos que ultimo también apunte a NULL, ya que la

lectura ha dejado la cola vacía.

4) IMPORTANCIAS DE LAS PILAS Y DE LAS COLAS:

-IMPORTANCIA DE LAS PILAS:

En los programas estas estructuras suelen ser fundamentales. La recursividad se simula en un computador con la ayuda de una pila. Asimismo muchos algoritmos emplean las pilas como estructura de datos fundamental, por ejemplo para mantener una lista de tareas pendientes que se van acumulando.

Las pilas ofrecen dos operaciones fundamentales, que son apilar y desapilar sobre la cima. El uso que se les de a las pilas es independiente de su implementación interna. Es decir, se hace un encapsulamiento. Por eso se considera a la pila como un tipo abstracto de datos.

-IMPORTANCIA DE LAS COLAS:

Las colas serán de ayuda fundamental para ciertos recorridos de árboles y grafos.

Las colas ofrecen dos operaciones fundamentales, que son encolar (al final de la cola) y desencolar (del comienzo de la cola). Al igual que con las pilas, la implementación de las colas suele encapsularse, es decir, basta con conocer las operaciones de manipulación de la cola para poder usarla, olvidando su implementación interna.

5) MOVIMIENTOS DE LAS PILAS Y DE LAS COLAS:

-MOVIMIENTOS DE LAS PILAS:

Manejo de saturación por desplazamiento. Se sabe que en la pila IP se presentó una condición de saturación. Para esto se requiere inicialmente conocer si hay un nodo disponible en una pila. Si lo hay se hace el desplazamiento y se deja el nodo para que se pueda hacer la inserción en la pila NP. Se debe observar, que la pila, la pila K, que va a proveer el nodo puede estar antes o después de la pila IP.

Figura 4.7 Saturación en la pila J. Se encontró espacio en la pila K. En este caso J > K.

 Algoritmo de desplazamiento. Este algoritmo busca una posición disponible, a partir de la primera pila, en cual de ellas hay nodo vacío. En caso de encontrar espacio antes de la pila IP (IP > K), llama a la rutina ATRAS; si, por el contrario, el espacio se encuentra delante de la pila IP (IP < K), se llama a la rutina ADELANTE. K es la variable que denota la pila donde hay espacio.

Precondición: 1 IP NPPoscondición: I es VERDADERO, si se puede asignar una posición a la pila IP, para hacer la inserción. I es FALSO, toda el área esta ocupada, hay condición de saturación.

SATURACION(IP,I)Comience

K <= 1SW<= 0Mientras ((NP > K),^,(SW=0)) Ejecute

Si (TOPE[K] < BASE[K+1]) Entonces

Si (K > IP) Entonces

Llame ADELANTE(IP,K)

Sino

Llame ATRAS(IP,K)

Fin-SiSW <= 1

Sino

K <= K+1

Fin-Si

Fin-MientrasSi (SW=0) Entonces

I <= F

Sino

I <= V

Fin-Si

Termine

 

Figura 4.8 Cuando IP < K, los datos se mueven hacia adelante comenzando con el nodo de dirección más alta LS, hasta el de más baja LI.

Precondición: IP < K Poscondición: Se han movido todos los datos, entre las pilas K y IP+1, para dejar una posición adicional, a la pila IP.

RUTINA ADELANTE(IP,K)Comience

LS <= TOPE[K]LI <= BASE[IP+1] +1L <= LSMientras (L LI) Ejecute

PILA[L+1] <= PILA[L]L <= L - 1

Fin-MientrasJ <= IP +1Mientras (J K) Ejecute

BASE[J] <= BASE[J] + 1TOPE[J] <= TOPE[J] +1J <= J+1

Fin-Mientras

Retorne

 

Figura 4.9 Se mueven los datos hacia atrás comenzando con LI hasta LS.RUTINA ATRAS (J, K)

Precondición: K<IP NPPoscondición: Se han movido todos los datos, entre las pilas K +1 e IP, para dejar una posición adicional, a la pila IP.

Comience

LI <= TOPE[IP]LS <= BASE[K+1]L <= LSMientras (L LI) Ejecute

PILA[L-1] <= PILA[L]L <= L + 1

Fin-MientrasJ <= K+1Mientras (J IP) Ejecute

BASE[J] <= BASE[J] - 1TOPE[J] <= TOPE[J] -1J <= J+1

Fin-Mientras

Retorne

La desventaja del desplazamiento para el manejo de la condición de saturación, es que solo provee un nodo para la pila donde se presentó dicha condición. Es posible que se presenten saturaciones sucesivas sobre la misma pila, deteriorando la eficiencia del sistema.

Reempaque. Cada que ocurre una saturación se hace un reempaque del área de memoria. Se basa en un cambio de tamaño de cada pila desde el último reempaque.

El algoritmo utiliza un arreglo llamado TOPEAN (I), con 1 I N, que guarda la distribución inicial de los topes. También utiliza los vectores D, y NBASE ambos con dimensión NP. El vector D lleva el crecimiento de cada pila desde el último reempaque, y NBASE, nueva base, es el vector que lleva las nuevas posiciones de la base después del reempaque.

Precondición: 1 IP NPPoscondición: I es VERDADERO, si se puede asignar una posición a la pila IP, para hacer la inserción. I es FALSO, toda el área esta ocupada, hay condición de saturación.

GUARDATOPESComience

K <= 1Mientras (K NP) Ejecute

TOPEAN[K] <= TOPE[K]K <= K+1

Fin-Mientras

Termine

SATURACION (IP,I)

-ALGORITMO G

Inicialmente detecta el incremento total de las pilas que crecieron y el crecimiento de cada pila. Luego, con base en la variable real P (0 P 1), se calculan los factores ALFA y BETA, con los cuales se asignan nuevas bases. Con la rutina REEMPAQUE se efectúa el movimiento de datos.

Comience

SUM <= MINC <= 0K <= 1Mientras (K NP) Ejecute

SUM <= SUM - (TOPE[K] -BASE[K])Si (TOPE[K] > TOPEAN[K]) Entonces

D[K] <= TOPE[K] -TOPEAN[K]INC <= INC + D[K]

Sino

D[K] <= 0

Fin-SiK <= K+1

Fin-MientrasSi (SUM > 0) Entonces

ALFA <= (P/NP) * SUMBETA <= ((1-P)/INC) * SUMK <= 2NBASE[1] <= BASE[1]Mientras (K N) Ejecute

NBASE[K] <= NBASE([K-1] +(TOPE[K-1] - BASE([K-1])+ ALFA + (BETA * D[K-1])K <= K+1

Fin-MientrasREEMPAQUEI <= V

Sino

I <= F

Fin-Si

Retorne

ALFA es un valor entero correspondiente al truncamiento de la fracción, es el número de posiciones que le corresponde a cada una de las pilas. BETA es el factor por el cual se hace el repartimiento de acuerdo al crecimiento, anterior a la condición de saturación, de cada pila. Quizá la parte más interesante de este algoritmo es el proceso general de reempaque. El reempaque no es trivial puesto que ciertas partes del contenido de la memoria se desplazan hacia adelante y otras hacia atrás; es importante tener cuidado para no regrabar ninguna posición de memoria que contenga datos mientras se está realizando una operación de movimiento.

ALGORITMO R

Comience

K <= 2Mientras (K NP) Ejecute

Si ( NBASE[K] < BASE([K] ) Entonces

ATRAS(K)

Sino

Si ( NBASE[K] > BASE([K] ) Entonces

ADELANTE(K)

Sino

TOPEAN[K] <= TOPE[K]

Fin-Si

Fin-SiK <= K+1

Fin-Mientras

Retorne

 

ALGORITMO ATRAS

Comience

LI <= BASE[K] + 1LS <= TOPE[K]CAMBIO <= (BASE[K]-NBASE[K])Mientras (LI LS) Ejecute

PILA[LI-CAMBIO] <= PILA[LI]L <= L + 1

Fin-MientrasBASE[K] <= NBASE[K]TOPE[K] <= TOPE[K] - CAMBIOTOPEAN[K] <= TOPE[K]

Retorne

Es un poco más difícil cuando la nueva base es mayor que la anterior.

Figura 4.10 Movimiento de datos hacia adelante. Primero se deben hacer los movimientos de más adelante, para no dañar la información

En el caso de la figura 4.10, se observa que no se pueden mover los datos de la pila 3. Es decir, se debe continuar buscando una condición en NBj Bj; de todas maneras siempre se cumple que NB(NP+1)=B(NP+1). Recordemos que para los diferentes procesos se creó la pila ficticia NP+1.

ALGORITMO ADELANTE

Comience

J <= KMientras (BASE[J] < NBASE[J]) Ejecute

J <= J +1

Fin-MientrasKN <= J -1Mientras (KN K) Ejecute

LI <= BASE[KN] + 1LS <= TOPE[KN]CAMBIO <= NBASE[KN] - BASE[KN]Mientras (LS LI) Ejecute

PILA[LS+CAMBIO] <= PILA[LS]LS <= LS + 1

Fin-MientrasBASE[KN] <= NBASE[KN]TOPE[KN] <= TOPE[KN] +CAMBIOTOPEAN[KN] <= TOPE[KN]KN <= KN -1

Fin-Mientras

Retorne

-MOVIMIENTOS DE LAS COLAS:

Eliminación del nodo delantero de la cola:

Figura 4.15 (a) Condición inicial crítica (b) Condición final una vez se ha eliminado el nodo delantero

ALGORITMO ELIM-COLA-CIR(DATO,I)

Precondición: Que haya cola.Poscondición: U apunta al último elemento de la cola, si hay elementos, sino, queda la cola en condición de cola vacía.

Comience

I <= VPRUEBA-COLA(VACIA)Si (VACIA) Entonces

I <= F

Sino

DATO <= COLA[D]Si (D=U) Entonces

D <= 0U <= D

Sino

D <= D + CSi (D = M) Entonces

D <= 1

SinoFin-Si

Fin-Si

Fin-Si

Termine

6) VENTAJAS DE LAS PILAS:

-Puede incluir instrucciones adicionales para saltos, entrada/salida, control de la pila, parada de la maquina etc.

-su ventaja mas importante reside en que no se necesita utilizar registros o variables temporales para los valores intermedios en las expresiones. La pila actúa como gestor y almacén de esos valores.

-La estructura del código permite que la traducción a código de pila sea prácticamente directa.

7) DESVENTAJAS DE LAS PILAS:

-su principal desventaja es que la mayoría de las arquitecturas actuales utilizan registros que no están organizados en forma de pila.

-Que se pueden insertar y eliminar elementos sólo por uno de los extremos

-Que los elementos de una pila serán eliminados en orden inverso al que se insertaron.

-Que el último elemento que se metió a la pila será el primero en salir de ella.

-Se tiene la limitación de espacio en memorias reservadas, propias de los arreglos. Luego de que el arreglo llegue a su máximo no será posible ampliar su tamaño.

8) VENTAJAS DE LAS COLAS:

-Los elementos se eliminan en el mismo orden en el que se insertaron. Por lo tanto el primer elemento en entrar a la cola será el primero en salir.

-Controlan el proceso de tareas en un sistema operativo hasta simulaciones del sistema de control aéreo de un aeropuerto.

- Las colas aseguran un tratamiento justo de los objetos que contienen, ya que siempre se extraerá el elemento que más tiempo lleva esperando.

9) DESVENTAJAS DE LAS COLAS:

-Las colas no guardan ningún orden, como tampoco lo guardan las listas no ordenadas.

-En las colas no se puede borrar un elemento cualquiera, se borra siempre el que está en la cabeza de la cola.

10) EJEMPLOS DE PILAS Y COLAS:

-EJEMPLOS DE PILAS:

EJEMPLO 1:

#include <stdio.h>

Int main (void){Struct tpila pila;Int elem;

Crear (&pila);If (vacía (&pila)) printf ("\nPila vacía.");If (llena (&pila)) printf ("\nPila llena.");Apilar (&pila, 1);Desapilar (&pila, &elem);Return 0;}

EJEMPLO 2:

Int main (void){Struct tpila *pila;Int elem;

Crear (&pila);If (vacía (pila)) printf ("\nPila vacía!");Apilar (pila, 1);Desapilar (pila, &elem);

Return 0;}

-EJEMPLOS DE COLAS:

EJEMPLO:

#include <stdio.h>

#define MAX_COLA 50 /* cola de 49 elementos */

Int main (void){ Struct tcola cola; Int elem; Crear (&cola); If (vacía (&cola)) printf ("\nCola vacía."); If (llena (&cola)) printf ("\nCola llena."); Encolar (&cola, 1); Desencolar (&cola, &elem); Return 0;}

 11) SINTAXIS Y DECLARACIONES DE LAS FUNCIONES:

Las funciones, son módulos de código independientes que pueden

Recibir valores de otras funciones, cuando se les haga una llamada

Y pueden devolver valores a quien les ha llamado.

(No es obligatorio ni que reciban ni que envíen)

La función principal es main, que es donde comienzan los programas.

Su utilización es igual que el resto de funciones, pero con la diferencia, que al enviarle valores será desde el sistema operativo,

Y también los valores, los devolverá al sistema operativo.

Las funciones deben ser declaradas en el general, después de los includes.

La declaración de funciones es así datos a devolver función (parámetros a recibir)

Si no va a devolver datos, se usa void. Lo mismo si no va a recibir parámetros.

Ejemplo:

Void Función (void);

Si queremos enviarle un entero y que devuelva un entero:

Int función (int a);

Así el entero que le enviemos, se llamara a en la función y si esta función devuelve un entero, al llamarla llevara a la izquierda un igual y la variable que este a la izquierda guardara el valor devuelto.

Se puede usar todo tipo de datos para enviar/recibir a/de las funciones

Esa es la declaración de funciones. Luego habrán de ser colocadas como se coloca el

Main (ósea con sus corchetes y escribiendo dentro el código que realicen)

Os quiero apuntar, que la orden para devolver valores es return.

Return variable; En el main, el return, se utiliza mas que nada para saber si el programa

Se ejecuto correctamente. Generalmente, un programador hace que devuelva

0 si su programa se ejecuto correctamente y otro numero si tuvo algún problema (el número será identificativo del problema)

Ejemplo:

Return 0;

Devolvería 0 en una función.

Código fuente con el ejemplo del uso de una función.

#include <stdio.h>

Int suma (int a,int b);

Void main ()

{ Int sumando1,sumando2,resultado;

Printf ("Mete el primer sumando:\n");

Scanf ("%d", &sumando1);

Printf ("\nMete el segundo sumando:\n");

Scanf ("%d", &sumando2);

Fflush (stdin); //borra el buffer del teclado ;)

Resultado=suma (sumando1, sumando2);

Printf ("\nEl resultado fue: %d", resultado);

Getchar ();

} int suma (int a, int b)

{ Int c;

c = a + b;

Return c;

}

Como dato curioso, para enviar parámetros desde el sistema operativo

(Ejemplo, cuando pones ping 127.0.0.1, la IP, es un parámetro)

Debemos declarar el main de la siguiente forma:

Int main (int argc, char * argv [])

Argc será el número total de argumentos.

Argv [0] será el nombre del exe

Argv [1] el primer parámetro

ect..

12) CARACTERISTICAS DE LAS FUNCIONES EN LENGUAJE C:

-Las funciones son porciones de código que devuelven un valor. -Permiten descomponer el programa en módulos que se llaman entre ellos. -En C no existe diferencia entre funciones y procedimientos: a todas las subrutinas se las llama funciones.

-La definición de una función especifica lo siguiente: nombre de la función número de argumentos que lleva y tipo de cada uno de ellos tipo de datos que devuelve Cuerpo de la función (el código que ejecuta)

-Las funciones son siempre globales, esto es, no se permite declarar una función dentro de otra.

-Las funciones son visibles sólo después de que se han declarado.

-Se pueden declarar funciones, especificando sólo su formato, pero no su cuerpo:

Int suma (int a, int b);

Lo anterior es una declaración de la función suma, que queda disponible para su uso, a pesar de no haber sido definido su cuerpo.

La declaración de una función de esta forma se llama prototipo.

Es buena práctica declarar al comienzo del programa los prototipos de las funciones que vamos a definir, incluyendo comentarios sobre su finalidad.

INTEGRANTES:

1)Aizpurua Christian

2)Infante Leidimar

3)Leon miriannis

4)luz karina

5)

6)

CIUDAD BOLIVAR MAYO DEL 2005

INTRODUCCION:

El lenguaje C nació en los Laboratorios Bell de AT&T y ha sido estrechamente asociado con el sistema operativo UNIX, ya que su desarrollo se realizó en este sistema y debido a que tanto UNIX como el propio compilador C y la casi totalidad de los programas y herramientas de UNIX, fueron escritos en C. Su eficiencia y claridad han hecho que el lenguaje ensamblador apenas haya sido utilizado en UNIX.

En 1972, Dennis Ritchie, toma el relevo y modifica el lenguaje B, creando el lenguaje C y reescribiendo el UNIX en dicho lenguaje. La novedad que proporcionó el lenguaje C sobre el B fue el diseño de tipos y estructuras de datos.

Los tipos básicos de datos eran "CHAR" (carácter), "INT" (enteros), "FLOAT" (Reales en simple presición), y "DOUBLE" (Reales en doble Presición). Posteriormente se añadieron los tipos "SHORT" (Enteros de longitud<=longitud de un int), "LONG" (Enteros de longitud >= longitud de un entero), "UNSIGNED" (Enteros sin signo), y "ENUMERACIONES". Los tipos estructurados básicos de C son las estructuras, las uniones, y los arrays. Estos permiten la definición y declaración de tipos de mayor complejidad.

Las instrucciones de control de flujo de C son las habituales de la programación estructurada: IF, FOR, WHILE, SWITCH - CASE, todas incluidas en su predecesorBCPL.

C incluye también punteros y funciones. Los argumentos de las funciones se pasan por valor, esto es copiando su valor, lo cual hace que no se modifiquen los valores de los argumentos en la llamada. Cuando se desea modificar los argumentos en la llamada, éstos se pasan por referencia, es decir, se pasan las direcciones de los argumentos. Por otra parte, cualquier función puede ser llamada recursivamente.

Este trabajo se centra particularmente en las funciones, pilas y colas todas estas estructuras del lenguaje. Las pilas son una estructura lineal donde las adiciones y eliminaciones se hacen por un extremoTambién se la conoce con el nombre de estructura LIFO ---->Last Input Output (ultimo en entrar primero en salir), las operaciones básicas que se pueden realizar con las pilas son: creación, adición, eliminación y listado. Las colas son una estructura de datos que consiste en realizar las inserciones por extremo y las eliminaciones por otro. Las colas también se llaman FIFO (primero entrar, primero en salir).

CONCLUSION:

Finalmente, C, que ha sido pensado para ser altamente transportable y para programar lo improgramable, igual que otros lenguajes tiene sus inconvenientes.

Carece de instrucciones de entrada/salida, de instrucciones para manejo de cadenas de caracteres, con lo que este trabajo queda para la librería de rutinas, con la consiguiente pérdida de transportabilidad.

La excesiva libertad en la escritura de los programas puede llevar a errores en la programación que, por ser correctos sintácticamente no se detectan a simple vista.

Por otra parte las precedencias de los operadores convierten a veces las expresiones en pequeños rompecabezas.

A pesar de todo, C ha demostrado ser un lenguaje extremadamente eficaz y expresivo.

En cierto modo y en la búsqueda de la verdad, de la lógica y de la razón hemos analizado profundamente los aspectos técnicos acerca de las diferentes estructuras dinámicas y no dinámicas que se encuentran en el lenguaje, centrándonos especialmente y con particular énfasis en las funciones todas ellas muy importantes para la programación estructurada, las colas ,las pilas herramientas indispensables para el ahorro del tiempo a nosotros los programadores solo la tecnología futura y los nuevos avances tecnológicos nos darán la luz y nos enseñaran el camino por el cual debe pasar la humanidad llevada de la mano por la informatica.

BIBLIOGRAFIA:

Estructuras dinámicas de datos. Algoritmos, acceso, propiedades, ejemplos.Dirección Página Web: http://c.conclase.net/edd/index.php?cap=000

INSTITUTO TECNOLOGICO de La Paz. Tutorial de Estructura de Datos. Dirección Página Web: http://www.itlp.edu.mx/publica/tutoriales/estru1/

ALGORITMIA ALGO+ - Algoritmos y Estructuras de Datos.Dirección Página Web: http://www.algoritmia.net/articles.php?id=13

100cia.com > Portada > Enciclopedia > Estructura_de_datos.Dirección Página Web: http://www.100cia.com/enciclopedia/Estructura_de_datos

El Rincón del Programador. Programación Genérica. Estructura de Datos. Listas.Dirección Página Web: http://rinconprog.metropoliglobal.com/CursosProg/ProgGen/Estr_Datos/index.php?cap=4