TERCER PARCIAL

ARBOLES BINARIOS:

Recorrido en preorden:

En este tipo de recorrido se realiza cierta acción (quizás simplemente imprimir por pantalla el valor de la clave de ese nodo) sobre el nodo actual y posteriormente se trata el subárbol izquierdo y cuando se haya concluido, el subárbol derecho. Otra forma para entender el recorrido con este metodo seria seguir el orden: nodo raiz, nodo izquierda, nodo derecha.

En el árbol de la figura el recorrido en preorden sería: 2, 7, 2, 6, 5, 11, 5, 9 y 4.

Recorrido en postorden:
 
En este caso se trata primero el subárbol izquierdo, después el derecho y por último el nodo actual. Otra forma para entender el recorrido con este metodo seria seguir el orden: nodo izquierda, nodo derecha, nodo raiz. En el árbol de la figura el recorrido en postorden sería: 2, 5, 11, 6, 7, 4, 9, 5 y 2.

Recorrido en inorden:

En este caso se trata primero el subárbol izquierdo, después el nodo actual y por último el subárbol derecho. En un ABB este recorrido daría los valores de clave ordenados de menor a mayor. Otra forma para entender el recorrido con este metodo seria seguir el orden: nodo izquierda,nodo raiz,nodo derecha. En el árbol de la figura el recorrido en inorden sería: 2, 7, 5, 6, 11, 2, 5, 4, 9.
Esquema de implementación:

EJERCICIO:

El recorrido en preorden de un determinado árbol binario es: GEAIBMCLDFKJH y en inorden IABEGLDCFMKHJ .

A)Dibujar el árbol binario.
B)Dar el recorrido enstorden.
C)Diseñar una función para dar el recorrido en postorden dado el recorrido en preorden e inorden y escribir un programa para comprobar el resultado del apartado anterior.

Las soluciones son las siguientes:

A) El árbol correspondiente es el de la siguiente figura:

B)El recorrido en postorden es IBAEDLFCHJKMG.

C)El código solución al tercer apartado es el siguiente:

/*Fichero: comprobar.c */
#include < stdio.h>
#include < stdlib.h>
#include < string.h>
char *preorden="GEAIBMCLDFKJH";
char *inorden="IABEGLDCFMKHJ";
char *postorden;
/*---------------------------------------*/
void post(char *pre,char *in,char *pos,int n)
{
int longIzqda;
if(n!=0){
pos[n-1]=pre[0];
longIzqda=strchr(in,pre[0])-in;
post (pre+1,in,pos,longIzqda);
post (pre+1+longIzqda,in+1+longIzqda,pos+longIzqda,n-1-longIzqda);
}
}
/*----------------------------------------*/
int main(int argc,char *argv[])
{
int aux;
aux=strlen(preorden);
postorden=(char *)malloc(aux*sizeof(char));
if (postorden){
printf("El preorden es: %s\n",preorden);
printf("El inorden es: %s\n",inorden);
post(preorden,inorden,postorden,aux);
postorden[aux]='\0';
printf("El postorden calculado es: %s\n",postorden);
free(postorden);
}
else{
fprintf(stderr,"Error: Sin memoria\n");
return 1;
}
return 0;
}

PLAN DE VUELO:

El plan de vuelo (flight plan) es el informe donde se indican todos los datos referentes a un vuelo. En éste, además de información técnica añadida por el piloto debe constar el lugar de salida, destino, altitud, velocidad de crucero, y todos los puntos por donde pasará la aeronave.

Estos puntos suelen ser estaciones VOR e intersecciones que ya están establecidas por la OACI (Organización de Aviación Civil Internacional) y que a su vez conforman las rutas aéreas. También se suelen incluir datos referentes a la aeronave como, carga de combustible, nombre del comandante, hora y fecha (ZULU). El plan de vuelo puede ser visual (VFR) o instrumental (IFR). En el caso de vuelo VFR se incluirán los puntos por donde pasará la aeronave, en el caso de vuelo IFR se deberán indicar puntos de salida y aproximación instrumental que ya están establecidos como estándares; Así como también las aerovías y puntos de reporte obligatorios. También en un plan de vuelo, se especifica:
- La altitud o nivel de vuelo a volar.
- El equipo de navegación que se cuenta abordo de la aeronave y el tipo de transpondedor.
- El equipo de salvamento que se encuentra abordo.
- La identificación o matrícula de la aeronave.
- Tipo de vuelo (Aviación General, Militar, Vuelo con Itinerario (Scheduled), Vuelo sin Itinerario (Non-Scheduled).
- Número de tripulantes (Y nombres).
- Categoría de la estela turbulenta (Ligera, Media, Pesada)
- Velocidad de crucero.
- Tiempo estimado en ruta (EET).
- El (Los) Aeropuerto(s) Alterno(s)

- Existe un compartimento llamado "OTROS DATOS" que sirve para señalar el nombre de los pasajeros; quién es el operador de la aeronave; si existiese un instructor abordo, se escribiría su nombre y número de licencia, al igual que el nombre de la escuela; si se cuenta con algún tipo de sistema especial abordo (ej. RMK/TCAS Onboard: Lo que significa que tiene el Sistema de Alerta de Colisión de Tráfico); entre otros.

- La autonomía de la aeronave (El combustible abordo expresado en HORAS).
- Personas (además de los tripulantes) abordo.
- Color y marcas de la aeronave.
- Observaciones.
- Nombre del piloto al mando, del primer oficial y sus números de licencia.
- El domicilio de los pilotos (o base de vuelo).
- Firma del piloto al mando.
- Firma del comandante del aeropuerto. si son vuelos internacionales los pilotos deben de hablar el idioma de ruta para poder comunicarce con los pasajeros y las aeromozas deben de dar una pequeña instruccion de como mantener la calma en caso de una turbulencia.

METODOS DE BUSQUEDA:

Busqueda Secuencial:
Definicion:

La búsqueda es el proceso de localizar un registro (elemento) con un valor de llave particular. La búsqueda termina exitosamente cuando se localiza el registro que contenga la llave buscada, o termina sin éxito, cuando se determina que no aparece ningún registro con esa llave.

Búsqueda secuencial, también se le conoce como búsqueda lineal. Supongamos una colección de registros organizados como una lista lineal. El algoritmo básico de búsqueda secuencial consiste en empezar al inicio de la lista e ir a través de cada registro hasta encontrar la llave indicada (k), o hasta al final de la lista. 
 

ORDENACION INTERNA:

Su finalidad es organizar ciertos datos (normalmente arrays o ficheros) en un orden creciente o decreciente mediante una regla prefijada (numérica, alfabética...). Atendiendo al tipo de elemento que se quiera ordenar puede ser: Ordenación interna: Los datos se encuentran en memoria (ya sean arrays, listas, etc), y son de acceso aleatorio o directo (se puede acceder a un determinado campo sin pasar por los anteriores). Ordenación externa: Los datos están en un dispositivo de almacenamiento externo (ficheros), y su ordenación es más lenta que la interna. Ordenación interna Los métodos de ordenación interna se aplican principalmente a arrays unidimensionales. Los principales algoritmos de ordenación interna son:

Selección: Este método consiste en buscar el elemento más pequeño del array y ponerlo en primera posición; luego, entre los restantes, se busca el elemento más pequeño y se coloca en segudo lugar, y así sucesivamente hasta colocar el último elemento. Por ejemplo, si tenemos el array {40,21,4,9,10,35}, los pasos a seguir son:
{4,21,40,9,10,35} <-- Se coloca el 4, el más pequeño, en primera posición : se cambia el 4 por el 40. {4,9,40,21,10,35} <-- Se coloca el 9, en segunda posición: se cambia el 9 por el 21. {4,9,10,21,40,35} <-- Se coloca el 10, en tercera posición: se cambia el 10 por el 40. {4,9,10,21,40,35} <-- Se coloca el 21, en tercera posición: ya está colocado. {4,9,10,21,35,40} <-- Se coloca el 35, en tercera posición: se cambia el 35 por el 40. Si el array tiene N elementos, el número de comprobaciones que hay que hacer es de N*(N-1)/2. private static void permuta (int[] V, int i, int j) { int t; t= V[i]; V[i]= V[j]; V[j]= t; } // Ordenacion por seleccion public static void seleccion (int[] V) { int L= V.length; int menor,i,j; for (i= 0; i < L-1; i++) { for (j= i+1,menor=i; j < L; j++) if (V[j] < V[menor]) menor= j; // el mas pequeño permuta (V, i, menor); } }

Burbuja: Consiste en comparar pares de elementos adyacentes e intercambiarlos entre sí hasta que estén todos ordenados. Con el array anterior, {40,21,4,9,10,35}:

Primera pasada: {21,40,4,9,10,35} <-- Se cambia el 21 por el 40. {21,4,40,9,10,35} <-- Se cambia el 40 por el 4. {21,4,9,40,10,35} <-- Se cambia el 9 por el 40. {21,4,9,10,40,35} <-- Se cambia el 40 por el 10. {21,4,9,10,35,40} <-- Se cambia el 35 por el 40. Segunda pasada: {4,21,9,10,35,40} <-- Se cambia el 21 por el 4. {4,9,21,10,35,40} <-- Se cambia el 9 por el 21. {4,9,10,21,35,40} <-- Se cambia el 21 por el 10. Ya están ordenados, pero para comprobarlo habría que acabar esta segunda comprobación y hacer una tercera. Si el array tiene N elementos, para estar seguro de que el array está ordenado, hay que hacer N-1 pasadas, por lo que habría que hacer (N-1)*(N-i-1) comparaciones. //metodo de la burbuja public static void burbuja (int[] V) { int L= V.length; boolean cambios; for (int i= 0; i < L-1; i++) { cambios= false; for (int j= L-1; j > i; j--) { if (V[j-1] > V[j]) { permuta (V, j-1, j); cambios= true; } } if (! cambios) break; } }

Inserción directa: En este método lo que se hace es tener una sublista ordenada de elementos del array e ir insertando el resto en el lugar adecuado para que la sublista no pierda el orden. Para el ejemplo {40,21,4,9,10,35}, se tiene: {40,21,4,9,10,35} <-- La primera sublista ordenada es {40}. Insertamos el 21: {40,40,4,9,10,35} <-- aux=21; {21,40,4,9,10,35} <-- Ahora la sublista ordenada es {21,40}.
Insertamos el 4: {21,40,40,9,10,35} <-- aux=4; {21,21,40,9,10,35} <-- aux=4; {4,21,40,9,10,35} <-- Ahora la sublista ordenada es {4,21,40}. Insertamos el 9: {4,21,40,40,10,35} <-- aux=9; {4,21,21,40,10,35} <-- aux=9; {4,9,21,40,10,35} <-- Ahora la sublista ordenada es {4,9,21,40}. Insertamos el 10: {4,9,21,40,40,35} <-- aux=10; {4,9,21,21,40,35} <-- aux=10; {4,9,10,21,40,35} <-- Ahora la sublista ordenada es {4,9,10,21,40}. Y por último insertamos el 35: {4,9,10,21,40,40} <-- aux=35; {4,9,10,21,35,40} <-- El array está ordenado. En el peor de los casos, el número de comparaciones que hay que realizar es de N*(N-1)/2. public static void inserccion(int[] V) { int L= V.length; int j, aux; for (int i= 0; i < L-1; i++) { j= i+1; aux= V[j]; while (j > 0 && aux < V[j-1]) { V[j]= V[j-1]; j--; } V[j]= aux; } } Inserción binaria: Es el mismo método que la inserción directa, excepto que la búsqueda del orden de un elemento en la sublista ordenada se realiza mediante una búsqueda binaria, lo que supone un ahorro de tiempo .

Shell: Es una mejora del método de inserción directa, utilizado cuando el array tiene un gran número de elementos. En este método no se compara a cada elemento con el de su izquierda, como en el de inserción, sino con el que está a un cierto número de lugares (llamado salto) a su izquierda. Este salto es constante, y su valor inicial es N/2 (siendo N el número de elementos, y siendo división entera). Se van dando pasadas hasta que en una pasada no se intercambie ningún elemento de sitio. Entonces el salto se reduce a la mitad, y se vuelven a dar pasadas hasta que no se intercambie ningún elemento, y así sucesivamente hasta que el salto vale 1.

Por ejemplo, lo pasos para ordenar el array {40,21,4,9,10,35} mediante el método de Shell serían: Salto=3: Primera pasada: {9,21,4,40,10,35} <-- se intercambian el 40 y el 9. {9,10,4,40,21,35} <-- se intercambian el 21 y el 10. Salto=1: Primera pasada: {9,4,10,40,21,35} <-- se intercambian el 10 y el 4. {9,4,10,21,40,35} <-- se intercambian el 40 y el 21. {9,4,10,21,35,40} <-- se intercambian el 35 y el 40. Segunda pasada: {4,9,10,21,35,40} <-- se intercambian el 4 y el 9. Con sólo 6 intercambios se ha ordenado el array, cuando por inserción se necesitaban muchos más.

Ordenación rápida (quicksort): Este método se basa en la táctica "divide y vencerás", que consiste en ir subdividiendo el array en arrays más pequeños, y ordenar éstos. Para hacer esta división, se toma un valor del array como pivote, y se mueven todos los elementos menores que este pivote a su izquierda, y los mayores a su derecha. A continuación se aplica el mismo método a cada una de las dos partes en las que queda dividido el array. 
 
 

FOTO DEL ARBOL GENEALOGICO:

SEGUNDO PARCIAL

CONCEPTO DE RECURSIVIDAD

La recursividad es una técnica de programación importante. Se utiliza para realizar una llamada a una función desde la misma función. Como ejemplo útil se puede presentar el cálculo de números factoriales. Él factorial de 0 es, por definición, 1. Los factoriales de números mayores se calculan mediante la multiplicación de 1 * 2 * ..., incrementando el número de 1 en 1 hasta llegar al número para el que se está calculando el factorial.

CONCEPTO DE ÁRBOL:

Es una estructura de datos ampliamente usada que imita la forma de un árbol (un conjunto de nodos conectados). Un nodo es la unidad sobre la que se construye el árbol y puede tener cero o más nodos hijos conectados a él. Se dice que un nodo a es padre de un nodo b si existe un enlace desde a hasta b (en ese caso, también decimos que b es hijo de a). Sólo puede haber un único nodo sin padres, que llamaremos raíz. Un nodo que no tiene hijos se conoce como hoja. Los demás nodos (tienen padre y uno o varios hijos) se les conoce como rama.

FOTOS DE EXPOSICIÓN:

PRACTICA DE LISITA ENLAZADAS DOBLEMENTE CIRCULARES

#include/* for printf*/

#include /* formalloc*/

typedef struct ns {

        void*data; 

        struct ns *next;

        } node;

        node*list_add(node**p,int i){

                                  /*algunos compiladores no requieren de un casting del valor del retorno para mal loc*/
                               node*n=(node*)for malloc(sizeof(node));
                                  if (n==NULL);
                                  return NULL;
                                  n ->next =*p;
                                  *p=n;
                                  n->data=i;
                                  return n;
                                  }
                                  void list_remove(node**p){ /*borrar cabeza*/
                                  if (*p!=NULL){
                                                node*n=*p;
                                                *p=(*p)->next;
                                                free (n);
                                                {
                                                 }
                                                 node**list_sarch (node**n,int i){
                                                                  while (*n!=NULL){
                                                                        return n;
                                                                        {
                                                                               n=&(*n)->next;
                                                                               }
                                                                               return NUL;
                                                                               }
                                                                               void list_printf(node*n){
                                                                                    if (n==NULL){
                                                                                                 printf("lista vacia =n");
                                                                                                 {
                                                                                                               while (n!=NULL);{
                                                                                                                     prinft("print %p%Pd=n",n,n->next,n->data);
                                                                                                                     n=n->next;
                                                                                                                     }
                                                                                                                     }
                                                                                                                     int main (void){
                                                                                                                         node*n=NULL;
                                                                                                                         list_add(&n,0);/*lista:0*/
                                                                                                                         list_add(&n,1);/*lista:10*/
                                                                                                                         list_add(&n,2);/*lista:210*/
                                                                                                                         list_add(&n,3);/*lista:3210*/
                                                                                                                         list_add(&n,4);/*lista:43210*/
                                                                                                                         list_prinft(n);
                                                                                                                         list_prinft(&n);
                                                                                                                         list_renove(&n); /*borrar primero(4)*/
                                                                                                                         list_renove(&n->next);/*borrar nuevo(2)*/
                                                                                                                         list_renove(list_search(&n,1));/*eliminar celda que contiene el 1(primera)*/
                                                                                                                         list_renove(&n->next); /*eliminar segundo nodo del final(0)*/
                                                                                                                         list_print(n);/*eliminar ultimonodo(3)*/
                                                                                                                         return 0;

PRACTICA DE FIBONACCI

#include
/***************************************************************************
* Ejemplo: Calculo iterativo del n-esimo termino de fibonacci
* Por definicion:
* Fibonacci(0) = 0
* Fibonacci(1) = 1
* Fibonacci(n) = Fibonacci(n - 1) + Fibonacci(n - 2)
***************************************************************************/
/***************************************************************************
* Funcion que calcula iterativamente el n-esimo termino de fibonacci
***************************************************************************/
double Fibonacci(int n) {
int i;
double Fibi, Fibn1, Fibn2;
switch (n) {
case 0 : return 0;
case 1 : return 1;
default :
Fibn2 = 0; /* Fibonacci(n - 2) */
Fibn1 = 1; /* Fibonacci(n - 1) */
for (i = 2; i <= n; i++) { Fibi = Fibn1 + Fibn2; Fibn2 = Fibn1; Fibn1 = Fibi; } return Fibi; } } /*************************************************************************** * Programa que calcula, de forma iterativa, el termino n-esimo de la * sucesion de fibonacci, para un valor n dado por el usuario. ***************************************************************************/ int main() { int n; /* Se solicita al usuario el valor de n */ printf("Ingrese el valor de n: "); scanf("%d", &n); /* scanf requiere puntero: & */ /* Imprime el fibonacci de n */ printf("El termino %d de Fibonacci es: %.0lf\n", n, Fibonacci(n)); }

PRACTICA "SUICIDA"

#include

int main()

{

int k;

int n;

int gente[100];

int die=0, cont=0;

int wisin;

printf("Introduzca el numero de personas:");

scanf("%d",&n);

printf("\nIntroduce el intervalo en que mataras: ");

scanf("%d",&k);

for(int c=0; c

gente[c] = (c+1);

}

printf("\n\n Las personas murieron el el orden siguiente:\n");

while(die != (n-1)) {

for(int c1=0; c1

if(gente[c1]!= 0) {

cont += 1;

if(cont ==k ){

cont = 0;

printf("%d\t",gente[c1]);

gente[c1] = 0;

die += 1;

}

}

}

}

for(int c2=0; c2 if(gente[c2] != 0) {

wisin = gente[c2];

}

}

printf("\n\nEl sobreviviente es el numero: %d\n\n", wisin);

system("pause");

return 0;

getch();

}

PRIMER PARCIAL

Jorge Antonio Sánchez Sandoval.

Grupo: 1301.

Docente: Ramón Lozano Zavala.

Carrera: Ing. en Sistemas Computacionales.

Entra a mi FACEBOOK con un click:

PROGRAMA 1

#include

#include

 /* A qui hacemos la declaración*/

struct tpila{

  int clave;

  struct tpila *sig;

};

/* Metemos los prototipos de implementación*/

void crear(struct tpila **pila);

int vacia(struct tpila *pila);

void apilar(struct tpila *pila, int elem);void desapilar(struct tpila *pila, int *elem);

void crear(struct tpila **pila)

{  *pila = (struct tpila *) malloc(sizeof(struct tpila));

  (*pila)->sig = NULL;

}

int vacia(struct tpila *pila){

  return (pila->sig == NULL);

}

void apilar(struct tpila *pila, int elem){

  struct tpila *nuevo;

  nuevo = (struct tpila *) malloc(sizeof(struct tpila));

  nuevo->clave = elem;  nuevo->sig = pila->sig;

  pila->sig = nuevo;

}

void desapilar(struct tpila *pila, int *elem){

  struct tpila *aux;

  aux = pila->sig;

  *elem = aux->clave;  pila->sig = aux->sig;

  free(aux);

}

int main(void)

{

/*Programa modo de prueba*/

  struct tpila *pila;

  int elem; 

  crear(&pila);

  if (vacia(pila)) printf("nPila vacia!");

  apilar(pila, 1);

  desapilar(pila, &elem); 

  return 0;

} 

PROGRAMA 2

#include

#include

typedef struct _nodo {

   int valor;

   struct _nodo *siguiente;

} tipoNodo;

typedef tipoNodo *pNodo;

typedef tipoNodo *Pila;

/* Funciones con pilas: */

void Push(Pila *l, int v);

int Pop(Pila *l);

int main() {

   Pila pila = NULL;

   Push(&pila, 20);

   Push(&pila, 10);

   printf("%d, ", Pop(&pila));

   Push(&pila, 40);

   Push(&pila, 30);

   printf("%d, ", Pop(&pila));

   printf("%d, ", Pop(&pila));

   Push(&pila, 90);

   printf("%d, ", Pop(&pila));

   printf("%d\n", Pop(&pila));

   getchar();

   return 0;

}

void Push(Pila *pila, int v) \{

   pNodo nuevo;

   /* Crear un nodo nuevo */

   nuevo = (pNodo)malloc(sizeof(tipoNodo));

   nuevo->valor = v;

   

   /* Añadimos la pila a continuación del nuevo nodo */

   nuevo->siguiente = *pila;

   /* Ahora, el comienzo de nuestra pila es en nuevo nodo */

   *pila = nuevo;

}

int Pop(Pila *pila) {

   pNodo nodo; /* variable auxiliar para manipular nodo */

   int v;      /* variable auxiliar para retorno */

   

   /* Nodo apunta al primer elemento de la pila */

   nodo = *pila;

   if(!nodo) return 0; /* Si no hay nodos en la pila retornamos 0 */

   /* Asignamos a pila toda la pila menos el primer elemento */

   *pila = nodo->siguiente;

   /* Guardamos el valor de retorno */

   v = nodo->valor; 

   /* Borrar el nodo *

   free(nodo);

   return v;

}

TAREAS:

¿QUE ES UNA LISTA ENLAZADA?

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 (punteros) al nodo anterior o posterior. El principal beneficio de las listas enlazadas respecto a los array 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.

Una lista enlazada es un tipo de dato auto-referenciado porque contienen un puntero o link a otro dato del mismo tipo. 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. Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas Doblemente Circulares.

FUNCIÓN BEGINNING OF BUFFER:

La estructura básica de la función beginning-of-buffer ya ha sido discutida. (See A Simplified beginning-of-buffer Definition.) Esta sección describe la parte compleja de la definición.

Como se describió previamente, cuando se invoca sin argumentos, beginning-of-buffer mueve el cursor al principio del búfer, dejando la marca en la posición previa. Sin embargo, cuando el comando se invoca con un número entre uno y diez, la función considera ese número como una fracción de la longitud del búfer, medida en decenas, y Emacs mueve el cursor esa fracción desde el principio del búfer. Así, se puede llamar a esta función con las teclas M-<, que moverán el cursor al comienzo del búfer, o con teclas como C-u 7 M-< que moverán el cursor a la posición que se encuentre al 70% desde el comienzo del búfer. Si se usa como argumento un número superior a diez, se moverá al final del búfer.

La función beginning-of-buffer puede llamarse con o sin argumentos. El uso del argumento es optativo.

INSERT AFTER:

Tarjeta de selección, el elemento, la cadena HTML, o un objeto jQuery, el conjunto combinado de elementos se insertarán después del elemento (s) especificado por este parámetro.

El insertAfter. Después de () y (). Métodos realizan la misma tarea. La principal diferencia está en la sintaxis, en concreto, en la colocación de los contenidos y objetivos. Con. Después de (), la expresión selector anterior el método es el contenedor después de lo cual se inserta el contenido. Con. InsertAfter (), por el contrario, el contenido precede al método, ya sea como una expresión de selección o de marcas creadas sobre la marcha, y se inserta después de que el contenedor de destino.

¿QUE ES UN BUFFER?

En informática, un buffer es una ubicación de la memoria en una computadora o en un instrumento digital reservada para el almacenamiento temporal de información digital, mientras que está esperando ser procesada. Por ejemplo, un analizador TRF tendrá uno o varios buffers de entrada, donde se guardan las palabras digitales que representan las muestras de la señal de entrada.