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.