Grafos No Dirigidos

Se muestran las soluciones al grafo no dirigido

Grafos dirigidos

Se muestran las soluciones al grafo no dirigido

Correos electronicos

Los integrantes de este blog son:

º Cabrera Romero Jesús Iván
correo: COLORES_TOXICOS@rocketmail.com

º Garcia Romero Maribel
correo: maribelgr.1190@hotmail.com

º Reyes Torres Yesenia
correo: yeslasix@gmail.com

º Véjar Rivera Gustavo
correo: gustavo-vejar@hotmail.com

Segundo examen | código lista ordenada

//BIBLIOTECAS ENCABEZADOS
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <ctype.h>

//VARIABLES GLOBALES
//***************************************************************************
struct lista_ordenada
{
char nombre [90];
struct lista_ordenada *sig;

};

typedef struct lista_ordenada LO;

typedef LO *LOPTR;

//PROTOTIPOS
//***************************************************************************
void insertar (LOPTR *, LOPTR *, char [] );
void menu ();
void eliminar (LOPTR, LOPTR*,LOPTR *, char[]);
void imprimir(LOPTR);

//FUNCIÓN PRINCIPAL //***************************************************************************
main()
{
LOPTR principio = NULL;
LOPTR final = NULL;

int opcion;
char item [30];
do{

menu ();
printf("Elige una opción: \n ");
scanf("%d", &opcion);

switch (opcion)
{
case 1: printf("Escribe un elemento : \n");
scanf("%s", item);
insertar(&principio, &final, item);
break;

case 2: printf("Elemento a eliminar:\n");
scanf("%s", &item);
eliminar(principio,&principio, &final,item);
break;

case 3: printf("\n ");
imprimir(principio);
break;

default: printf("¡HASTA LUEGO!");
getch();
}
}while(opcion !=4);

}

void menu()
{
system("cls");
printf("*********************************************************");
printf("\n OPERACIONES DISPONIBLES CON LA LISTA ORDENADA\n");
printf("*********************************************************");
printf("\n\n 1 AGREGAR UN NOMBRE A LA LISTA ORDENADA \n");
printf("\n\n 2 ELIMINAR UN NOMBRE DE LA LISTA ORDENADA\n");
printf("\n\n 3 IMPRIME LOS ELEMENTOS DE LA LISTA ORDENADA \n");
printf("\n\n 4 SALIR DEL PROGRAMA \n");
printf("*********************************************************\n\n");
}

//FUNCION INSERTAR*******************************************************
void insertar (LOPTR *primero, LOPTR *ultimo, char apellido [30])
{
LOPTR aux= (LOPTR) malloc (sizeof (LO));
LOPTR actual, adelante;
int comp;

strcpy (aux -> nombre, apellido);
aux ->sig = NULL;

if (*primero == NULL)
{
*primero = aux;
*ultimo = aux;
goto salida;
}

comp= strcmp (apellido, (*primero)->nombre);

if (comp <0 )
{
aux->sig= *primero;
*primero =aux;
goto salida;
}


comp =strcmp (apellido, (*ultimo)->nombre);

if (comp >0)
{
(*ultimo)->sig = aux;
*ultimo =aux;
goto salida;
}
adelante = actual->sig;
actual= *primero;


comp = strcmp(adelante->nombre, apellido);

if(comp <1)
{
aux->sig = adelante;
actual->sig = aux;
goto salida;

}
/*
actual= actual->sig;
adelante = actual->sig;

*/
salida: ;
}
//FUNCION ELIMINAR*********************************************************
void eliminar (LOPTR aux, LOPTR *primero, LOPTR *ultimo, char apellido [30]){
int comp;
LOPTR borrar;

if(aux==NULL)
{
printf("No se puede eliminar, lista esta vacia\n");
printf("Seleccione otra opcion...");
getch();
}
else {
borrar=aux;
comp= strcmp (apellido, (*primero)->nombre);
if (aux==*primero)
{
*primero = (*primero)->sig;
getch();
}
comp =strcmp (apellido, (*ultimo)->nombre);

if (aux= =*ultimo)
{
*ultimo = (*ultimo)->sig;
getch();

}
}
}
//FUNCION IMPRIMIR******************************************************
void imprimir(LOPTR aux){
if (aux ==NULL)
{ printf("La lista esta vacia...");
printf(" Enter para continuar...");
getch ();
}
else{
printf(" \n La lista contiene los siguientes elementos... \n \t");
while( aux !=NULL)
{
printf(" \n %s \n \t", aux->nombre);
aux = aux->sig;
}
printf(" \n \t Enter para continuar... \n \t");
getch ();
}
}

Ejercicio Factorial

Código fuente

Menú

Opción

Ejercicio Colas

Código fuente del programa


#include
#include
#include
#include
struct colanodo
{
char nombre;
struct colanodo *sig;
};

typedef struct colanodo COLA;
typedef COLA *COLAPTR;
//prototipo
void enqueue (COLAPTR *, COLAPTR *, char);
//prototipo
void dequeue (COLAPTR *);
//prototipo de escribe cola
void menu();
int nohaycola (COLAPTR aux);
void escribecola (COLAPTR);
void escribecola (COLAPTR aux)
{
if (nohaycola (aux))
printf("\n NO HAY COLA: ");
else
{
printf("LA COLA : ");
printf("\n PRINCIPIO ** ");
while (aux!= NULL)
{
printf("%c <--", aux -> nombre);
aux = aux->sig;
}
printf("FINAL DE LA COLA "); } } //funcion
void dequeue (COLAPTR *elim)
{
COLAPTR eliminar;
char sale;
eliminar = *elim;
*elim = eliminar->sig;
//aqui estoy pasandp la siguiente estructura
sale = eliminar->nombre; //aquui estoy pasando el siguiente valor
free (eliminar);
printf("%c, FUE ELIMINADO DE LA COLA: ", sale);
}
//funcion hay cola
int nohaycola (COLAPTR aux)
{
return aux == NULL;
}
//Ahora haremos la impresion para verificar que funciona
//funcion enqueue la funcion es nula
void enqueue (COLAPTR *adela, COLAPTR *atras, char valor)
{
COLAPTR aux = (COLAPTR) malloc(sizeof(COLA));
//siempre que metemos un elemento a la cola su apuntador sera NULL
aux-> sig = NULL;
aux->nombre = valor;
if( nohaycola(*adela))
{
*adela = aux;
*atras = aux;
}
//esto fue en el caso de que no hubiere cola
// pero que pasa si si hay cola
else
{
(*atras) -> sig = aux;
*atras = aux;
}
}
main ()
{
COLAPTR principio = NULL, final = NULL;
int opcion;
char item;
for(;;)
{
// While (opcion != 4)
menu();
printf("\n ELIGE SOLO UNA OPCION : ");
fflush(stdin);
scanf("%d", &opcion);
switch(opcion)
{
case 1: printf("\n AGREGAR CARACTER A LA COLA: ");
fflush(stdin);
scanf("%c", &item);
enqueue(&principio, &final, item);
getch ();
break;
case 2: dequeue(&principio);
printf("\n ELEMENTOS QUE CONTIENE LA COLA : ");
escribecola (principio);
getch ();
break;
case 3: printf("\n ELEMENTOS QUE CONTIENE LA COLA : "); escribecola (principio);
getch ();
break;
// case 3:
// printf("\n TERMINADO EL PROGRAMA: \n");
// getch ();
// break; } } }
void menu()
{
system("cls");
printf("\n\n OPERACIONES DISPONIBLES CON LA COLA: \n\n");
printf("\n\n 1 (ENQUEUVE) AGREGAR UN NOMBRE A LA COLA\n");
printf("\n\n 2 (DEQUEVE) ELIMINAR UN NOMBRE DE LA COLA\n");
printf("\n\n 3 IMPRIME LOS ELEMENTOS DE LA COLA \n");
printf("\n\n 4SALIR DEL PROGRAMA \n");
}


Pantallas que muestran lo que realiza el programa

Menu principal

Primera opcion del menú

Segunda Opción del Menú

Tercera pantalla del programa

Ejercicio Pilas

Código fuente

#include < stdlib . h >

#include < stdio . h >

#include < conio . h >

#include < windows . h >

struct pilanodo

{

int dato;

struct pilanodo *sig;

};

typedef struct pilanodo PILA;

typedef PILA *PILAPTR;

void menu(void);

void push (PILAPTR * aux, int valor)

{

PILAPTR aux1;

aux1 = (PILAPTR)malloc(sizeof(PILA));

if (aux != NULL)
{

aux1->dato= valor;

aux1->sig = NULL;

if (*aux == NULL)

*aux = aux1;

else

{

aux1->sig = *aux;

*aux = aux1;

}

}
else printf ("\n\n No hubo espacio suficiente en la memoria");

}

void imprimepila (PILAPTR);

int pop (PILAPTR *);

int estavacia(PILAPTR);

int estavacia(PILAPTR aux)

{

return aux == NULL;

}

int pop(PILAPTR *aux)

{

PILAPTR aux1;

int salevalor;

aux1 = *aux;

*aux = aux1-> sig;

// Tambien le puedo asignar *aux = *aux->sig es una segunda forma

salevalor = aux1->dato;

free(aux1);

return (salevalor);

}

void imprimepila (PILAPTR aux)

{

do {

printf("%d", aux->dato);

printf ("\n");

aux= aux->sig;

}

while ( aux != NULL);

}

main ()

{

PILAPTR pilaptr= NULL;

int opcion, valor;

do{

menu();

printf("\n\n ELIGE UNA OPCION...\n");

scanf("%d",&opcion);

//while (opcion !=2)

//{

switch (opcion)

{

case 1: printf("\n\n DAME EL VALOR DEL NODO : \n");

scanf("%d",&valor);

//le llamaremos push a la funcion agregar.

push(&pilaptr, valor);

break;

case 2: if(!estavacia(pilaptr))

printf("\n\n EL VALOR EXTRAIDO DE LA PILA ES: %d", pop(&pilaptr));

getch ();

break;

case 3: printf("\n\n Los valores de al pila son:\n");

imprimepila (pilaptr);

getch ();

break;

case 4: printf("\n\n Presione enter para salir de la ejecucion \n");

}

}

while (opcion !=4);

}

void menu(void)

{

system("cls");

printf("\n\n OPERACIONES DISPONIBLES CON LA PILA \n\n Elija una opcion:");

printf("\n\n 1 Agregar un nodo a la pila\n");

printf("\n\n 2 Eliminar nodos en la pila\n");

printf("\n\n 3 Mostrar la pila \n");

printf("\n\n 4 Finalizar \n");

}

Pantallas ejecutando el programa

Menu

Primera opción

Segunda opción

Tercera opción

Pantallas de Primer Examen Parcial

Se muestran las pantallas resultantes del código fuente antes publicado del primer examen parcial

Primera pantalla

Captura de datos

Resultado de la captura

Respuestas de Examen

1. Que es una Estructura de Datos? (valor 1 punto)

Cualquier colección o grupo de datos de tal manera organizados que tengan asociados un conjunto de operaciones que permitan manipularlos.

2. Para que sirve una estructura de datos? (valor 1 punto)

Es fundamental para el desarrollo de sentencias complejas pro lo tanto para el manejo de información.

3. Para que se utilizan los apuntadores en Estructuras de datos dinámicas? (valor 1 punto)

Para tener acceso a una dirección de memoria de una variable, además son útiles para regresar valores a la rutina de donde se le llama

4. En que consiste la Abstracción de Datos? (valor 1 punto)

En resaltar características más importantes o escenciales de algo o alguien para representarlo mediante un lenguaje escrito o gráfico.

5. Qué es un tipo de Datos Abstracto? (valor 1 punto)

Es un TDA, son modelos con los cuales se representan estructuras con propiedades establecidas para modelarlo conceptualmente, no hacen referencia a una aplicacion especifica, la finalidad es la generalización de la definición del objeto.

Código Fuente del Primer Examen

Se muestra el código fuente del primer examen
Autores:
Cabrera Romero Jesús Iván
Garcia Romero Maribel
Reyes Torres Yesenia
Véjar Rivera Gustavo


#include
#include
#include
#include
#include
#include
struct producto{
char nom[10];
int clave;
float costo;
float pventa;
char mes;
};
struct producto catalogo;

void ingreso()
{
printf("\n Dame el nombre del producto:");
scanf("\n%s",&catalogo.nom);

printf("\n Dame la clave del producto :");
scanf("\n%d",&catalogo.clave);

printf("\n Dame el costo del producto:");
scanf("\n%f",&catalogo.costo);

printf("\n Dame el precio de venta del producto:");
scanf("\n%f",&catalogo.pventa);

printf("\n Dame el mes de venta del producto (ej. enero):");
scanf("\n%s",&catalogo.mes);

getch();

}
void ingresodatos ()
{
printf("\n NOMBRE DEL PRODUCTO :%s", &catalogo.nom);
printf("\n CLAVE DEL PRODUCTO :%d", catalogo.clave);
printf("\n COSTO DEL PRODUCTO :%.2f", catalogo.costo);
printf("\n PRECIO DE VENTA DEL PRODUCTO :%.2f", catalogo.pventa);
printf("\n MES DE VENTA DEL PRODUCTO :%s", &catalogo.mes);
getch();

}
main()
{
system("cls");
printf("\n Este es un programa para pasar el primer examen parcial\n");
ingreso();
ingresodatos();

}

Ejercicio en clase 4

Se muestra el código fuente de la clase

#include
#include
main ()
{
int x;
int * ptr;
ptr -&x;x=8;
printf ("%p", ptr);
printf ("%p",&ptr);
printf ("\n\n x=%d",x);
*ptr=16;printf ("\n\n ahora x=%d",x);
getch ();
}


Se muestra los resultados que se obtuvieron

Ejercicio en clase 3

Se muestra el código fuente

#include



#include



main ()



{



int x;



int * ptr;



ptr -&x;



x=8;



printf ("%p", ptr);



printf ("%p",&ptr);



printf ("\n\n x=%d",x);



getch ();



}

Se muestra la salida del programa

Ejercicio en clase 2

Código fuente del ejercicio en clase

#include



#include



main ()



{



int x;int * ptr;



ptr -&x;



x=8;



printf ("%p", ptr);



printf ("%p",&ptr);



getch ();



}

Se muestra la salida del programa ejecutandose

Ejercicio en clase 1

Se anexan los ejercicios de clase

Código fuente del primer ejemplo:

#include < conio.h >

#include < stdio.h >

main ()

{

int x;

int * ptr;

ptr -&x;

printf ("%p", ptr);

getch ();
}