Código Árbol Binario

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <windows.h>

struct arbol{
int info;
struct arbol *izq;
struct arbol *der;
};

typedef struct arbol nodo;
typedef nodo *aPTR;
void insertar(aPTR*LOPTR, int n);
void imprimir(aPTR LOPTR);
void menu();

main()
{
aPTR LOPTR=NULL;
int i, opc;
menu(),
printf(" \n");
scanf("%d",&opc);
while(opc!=3){
    switch(opc)
{
    case 1:{
            printf("\n Insertar elemento: ");
            scanf("%d",&i);
            insertar(&LOPTR,i);
               system("cls");
            menu();
            break;    }
           
    case 2: {
            printf("\n");
            imprimir(LOPTR);
            getch();
            system("cls");
            menu();
            break; }
           
    case 3: {
            printf("¡ADIOS!");
            getch();
            break; }
default:
printf("\nERROR EN LA SELECCION\n");
getch();
system("cls");
menu();
break;
}
printf("\n Selecciona una Opcion: ");
scanf("%d",&opc);
}
}
void menu()
{
printf("\n*********** ARBOLES BINARIOS ***********");
printf(" \nSeleccione una opcion:\n");
printf("\n 1 Insertar elemento");
printf("\n 2 Imprimir elementos");
printf("\n 3 Salir\n\n");
}
void insertar(aPTR*r,int x)
{
aPTR nuevo,ant,actual;
nuevo=(arbol*)malloc(sizeof(arbol));
if(nuevo!=NULL)
{
nuevo->info=x;
nuevo->der=NULL;
nuevo->izq=NULL;
ant=NULL;
actual=*r;
printf("%d",nuevo->info);
while(actual!=NULL && x>actual->info)
{
ant=actual;
actual=actual->izq;
}
if(ant==NULL)
{
nuevo->izq=*r;
*r=nuevo;
}
else
{
ant->izq=nuevo;
nuevo->izq=actual;
}
}
}
void imprimir(aPTR actual)
{
if(actual==NULL)
printf("\n Arbol vacio, inserta un valor ... \n\n");
else
{
printf("\n Contenido del arbol: ");
while(actual!=NULL)
{
printf("\n\n| Izquierda: %d | ",actual->info);
actual=actual->izq;
printf("Centro: %d |",actual->info);
actual=actual->izq;
printf(" Derecha: %d |",actual->info);
actual=actual->izq;

}
}
}

Ejercicio Factorial

//UNIVERSIDAD NACIONAL AUTÒNOMA DE MÉXICO.
//FAC. CONTADURÍA Y ADMINISTRACIÓN.
#include <stdio.h>
#include <conio.h>

//PROGRAMA QUE CALCULA EL FACTORIAL DE UN NUMERO.
unsigned long factorial(int);

main(){
int numero;
unsigned long fac;
do{
printf("Ingrese el nùmero que desea: ");
scanf("%d", &numero);
}

while (numero <0 numero >25);
fac = factorial (numero);
printf("\nEl factorial de %d es : %ld \n", numero, fac);
getch ();
}

unsigned long factorial(int numero)
{
if (numero == 0 )
return 1;
else
return numero*factorial(numero-1);
}

Ejercicio Factorial

#include

#include

int factorial(int n);

main()

{

int numero;

printf("\n Introduce un número entero: ");

scanf("%d", &numero);

printf("\n El factorial de %d es: %d", numero, factorial(numero));

getch();

}

int factorial (int numero)

{

if (numero == 1)

return 1;

else

return numero * factorial (numero - 1);

}

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

/* Objetivo: Mostrar el Factorial de cierto número capturado
Fecha: Enero 2012
Autor: Maribel García
*/

#include <stdio.h>
#include <conio.h>

/* Objetivo: Mostrar el Factorial de cierto número capturado
Fecha: Enero 2012
Autor: Maribel García
*/

#include <stdio.h>
#include <conio.h>

int main()
{

int N,i=1,factorial=1,resultado;

printf("Ingresa el numero para sacar su factorial\n");
scanf("%d",&N);

for(i=1;i<=N;i++)
{

factorial=factorial*i;

resultado=N;

if(resultado==i)
{
printf("El factorial de %d es %d\n",N,factorial);
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

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();

}

Ejercicios - Estructuras

#include

#include

struct alumno {

char cuenta [9];

char nombre [20];

char sexo;

int edad;

float promedio;};

struct alumno unam;

struct alumno*ptr;

main()

{

unam.sexo = 'M';

unam.edad =18;

unam.promedio=9.45;

ptr=&unam;

printf ("\n sexo : %c", unam.sexo);

printf ("\n edad : %d",ptr->edad );

printf ("\n promedio : %4.2f",(*ptr).promedio);

getch();

}

// . -> apunta y punto

EJERCICIO 4 14 Dic 2011 código fuente

// GUSTAVO VÉJAR RIVERA
# include <conio.h>
# include <stdio.h>
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();
}

Ejercicio 14 Diciembre 2011 Código fuente

//GUSTAVO VEJAR RIVERA
# include <conio.h>
# include <stdio.h>
main()
{
int x;
int *ptr;
ptr=&x;
x=8;
printf("%p",ptr);
printf("%p",&ptr);
printf("\n\n x= %d", x);
getch();
}

Ejercicio 2 15 dic. 2011código fuente

//GUSTAVO VÉJAR RIVERA
#include <stdio.h>
#include <conio.h>

struct alumno {
char cuenta[9];
char nombre[35];
char sexo;
int edad;
float promedio;
};

struct alumno unam;
struct alumno *ptr;
main ()
{
unam.sexo = 'M';
unam.edad = 18;
unam.promedio = 9.45;

ptr = &unam;

printf("\n\n SEXO :%c", unam.sexo);
printf("\n\n EDAD :%d", (*ptr).edad);
printf("\n\n PROMEDIO:%.2f", ptr->promedio);



getch ();
}

Ejercicio 15 dic 2011 código fuente

//GUSTAVO VÉJAR RIVERA

#include <stdio.h>
#include <conio.h>
main(){
struct alumno {
char cuenta[9];
char nombre[35];
char sexo;
int edad;
float promedio;
};

struct alumno unam [45];
struct alumno * ptr;
ptr= & unam [0];
getch ();
}

Ejercicio 14 de dic 2011 código fuente

# include <conio.h>
//GUSTAVO VÉJAR RIVERA
# include <stdio.h>
main()
{
int x;
int *ptr;
ptr=&x;
x=8;
printf("%p",ptr);
printf("%p",&ptr);
printf("\n\n x= %d", x);
getch();
}

Ejercicio 14 de dic 2011 código fuente.

//GUSTAVO VÉJAR RIVERA

# include <conio.h>
# include <stdio.h>
main()
{
int x;
int *ptr;
ptr=&
x;
printf("%p", ptr);

getch ();

}

Ejercicio 4

#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 ();
}

Ejercicio Apuntadores

#include
#include


main()
{
int x;
int*ptr;
ptr=&x; // ptr apunte a x q es la variable
x=8;
printf("%p", ptr); // localidad de x
printf("%p",&ptr); //imprimiendo la direccion de memoria del apuntador
printf("\n\n x = %d", x);
*ptr=16; //el valor de la variable q esta siendo apuntada por el apuntador
printf("\n\n ahora x = %d",x);
getch ();
}

Ejercicio 1

#include

#include

main ()

{

int x;

int * ptr;

ptr -&x;

printf ("%p", ptr);

getch ();

}

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