ARBOLES BINARIOS

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


struct nodoarbol{
       struct nodoarbol *izqnodo;
       int info;
       char letra;
       struct nodoarbol *dernodo;
       };
typedef struct nodoarbol NODO;
typedef NODO *ARBOL;

       void insertanodonuevo(ARBOL *, int,char);
       void inorden (ARBOL);
       void preorden (ARBOL);
       void postorden (ARBOL);
       void treefree (ARBOL);
    
main()
{
  int i, n, elementos;
  char newnod, chain;
  ARBOL raiz=NULL;

  printf("\n\nCuantos nodos desea insertar: ");
  scanf("%d",&n);
  for (i=0;i<n;i++)
  {
      fflush(stdin);
      printf("\nIntroduce un numero: ");
      scanf("%d",&elementos);
      fflush(stdin);
      printf("Introduce una letra: ");
      scanf("%c",&chain);
      insertanodonuevo(&raiz,elementos,chain);
      }
      system("cls");
  printf("\n\nPreorden:  ");
  preorden(raiz);
  printf("\n\nInorden:   ");
  inorden(raiz);
  printf("\n\nPostorden: ");
  postorden(raiz);
  getch();
  treefree(raiz);
  raiz=NULL;
  return 0;
}


void insertanodonuevo(ARBOL *rarbol, int nuevo,char l)
{
     if (*rarbol==NULL)
     {
     *rarbol=(NODO *)malloc(sizeof(NODO));
     if(*rarbol!=NULL)
     {
     (*rarbol)->info=nuevo;
     (*rarbol)->letra=l;
     (*rarbol)->izqnodo=NULL;
     (*rarbol)->dernodo=NULL;
     }
     else {printf("\nMEMORIA NO DISPONIBLE\n");}
     }
     else
     if(nuevo<(*rarbol)->info)
     insertanodonuevo(&((*rarbol)->izqnodo),nuevo,l);
     else
     if(nuevo>(*rarbol)->info)
     insertanodonuevo(&((*rarbol)->dernodo),nuevo,l);
     }
  
void preorden (ARBOL rarbol)
{
     if(rarbol!=NULL)
     {
                  
     printf("%d",rarbol->info);
     printf("%c",rarbol->letra);
     preorden(rarbol->izqnodo);
     preorden(rarbol->dernodo);
     }
}

void inorden(ARBOL rarbol)
{
     if(rarbol!=NULL)
     {
     inorden(rarbol->izqnodo);
     printf("%d", rarbol->info);
     printf("%c",rarbol->letra);
     inorden(rarbol->dernodo);
     }
}

void postorden(ARBOL rarbol)
{
     if(rarbol!=NULL)
     {
                  
     postorden(rarbol->izqnodo);
     postorden(rarbol->dernodo);
     printf("%d", rarbol->info);
     printf("%c",rarbol->letra);
     }
}

void treefree(ARBOL rarbol)
{
     if(rarbol!=NULL)
{
     treefree (rarbol->izqnodo);
     treefree(rarbol->dernodo);
     treefree (rarbol);
}
}

LISTA DOBLEMENTE ENLAZADA

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

#define ASCENDENTE 1
#define DESCENDENTE 0

typedef struct _nodo {
           char valor;
   struct _nodo *siguiente;
   struct _nodo *anterior;
} tipoNodo;

typedef tipoNodo *pNodo;
typedef tipoNodo *Lista;

/* Funciones con listas: */
void Insertar(Lista *l, char v);
void Borrar(Lista *l, char v);

void BorrarLista(Lista *);
void MostrarLista(Lista l, char orden);

int main() {
    int a,x=0,c;
    char b,d;
   Lista lista = NULL;
   pNodo p;
printf("\nIngresa la cantidad de elementos a Insertar:");
scanf("%d",&a);
fflush(stdin);
for(x=1;x<=a;x++)
{fflush(stdin);
   printf("\nDigita una Letra:");
   scanf("%c",&b);
   Insertar(&lista, b);
}

   MostrarLista(lista, ASCENDENTE);

   MostrarLista(lista, DESCENDENTE);
getch();
printf("\nIngresa la cantidad de elementos a Borrar:");
scanf("%d",&c);
fflush(stdin);
for(x=1;x<=c;x++)
{
   printf("\nDigita Letra a Eliminar:");
   scanf("%c",&d);

   Borrar(&lista, d);
}  

   MostrarLista(lista, ASCENDENTE);
   MostrarLista(lista, DESCENDENTE);

   BorrarLista(&lista);
getch();
   return 0;
}

void Insertar(Lista *lista, char v)
{
    pNodo nuevo, actual;

   /* Crear un nodo nuevo */
   nuevo = (pNodo)malloc(sizeof(tipoNodo));
   nuevo->valor = v;
  
   /* Colocamos actual en la primera posición de la lista */
   actual = *lista;
   if(actual) while(actual->anterior) actual = actual->anterior;
   /* Si la lista está vacía o el primer miembro es mayor que el nuevo */
   if(!actual || actual->valor > v) {
      /* Añadimos la lista a continuación del nuevo nodo */
      nuevo->siguiente = actual;
      nuevo->anterior = NULL;
      if(actual) actual->anterior = nuevo;
      if(!*lista) *lista = nuevo;
   }
   else
   {
      /* Avanzamos hasta el último elemento o hasta que el siguiente tenga
         un valor mayor que v */
      while(actual->siguiente &&actual->siguiente->valor <= v)
         actual = actual->siguiente;
      /* Insertamos el nuevo nodo después del nodo anterior */
      nuevo->siguiente = actual->siguiente;
      actual->siguiente = nuevo;
      nuevo->anterior = actual;
      if(nuevo->siguiente) nuevo->siguiente->anterior = nuevo;
   }
}

void Borrar(Lista *lista, char v) {
   pNodo nodo;
  
   /* Buscar el nodo de valor v */
   nodo = *lista;
   while(nodo && nodo->valor < v) nodo = nodo->siguiente;
   while(nodo && nodo->valor > v) nodo = nodo->anterior;

   /* El valor v no está en la lista */
   if(!nodo || nodo->valor != v) return;
  
   /* Borrar el nodo */
   /* Si lista apunta al nodo que queremos borrar, apuntar a otro */
   if(nodo == *lista)
     if(nodo->anterior) *lista = nodo->anterior;
     else *lista = nodo->siguiente;
  
   if(nodo->anterior) /* no es el primer elemento */
      nodo->anterior->siguiente = nodo->siguiente;
   if(nodo->siguiente) /* no es el último nodo */
      nodo->siguiente->anterior = nodo->anterior;
   free(nodo);
}

void BorrarLista(Lista *lista) {
   pNodo nodo, actual;

   actual = *lista;
   while(actual->anterior) actual = actual->anterior;

   while(actual) {
      nodo = actual;
      actual = actual->siguiente;
      free(nodo);
   }
   *lista = NULL;
}

void MostrarLista(Lista lista, char orden) {
   pNodo nodo = lista;

   if(!lista) printf("Lista vacía");

   nodo = lista;
   if(orden == ASCENDENTE) {
      while(nodo->anterior) nodo = nodo->anterior;
      printf("Orden ascendente: ");
      while(nodo) {
         printf("%c -> ", nodo->valor);
         nodo = nodo->siguiente;
      }
   }
   else {
      while(nodo->siguiente) nodo = nodo->siguiente;
      printf("Orden descendente: ");
      while(nodo) {
         printf("%c -> ", nodo->valor);
         nodo = nodo->anterior;
      }
   }
  
   printf("\n");
}

LISTA SIMPLE LIGADA (ALGORITMO)

.- Inicio

2.- INICIO FUNCION INICIAL  (A)

3.-A y B son variables de tipo puntero.

(A)

 A->INFORMACIÓN

 A->LIGA=NULL

       Repetir

(B)

 B->INFORMACIÓN

 B->LIGA=  A y A = B

4.- Fin FUNCION INICIAL

5.- Inicio FUNCION FINAL (A)

A->INFORMACIÓN

A->LIGA=NULL y  T=A

       Repetir

(B)

B->INFORMACIÓN

B->LIGA=NULL, T->LIGA=B y T=B

6.-Fin FUNCION FINAL 

7.- Inicio FUNCION RECURSIVIDAD

8.- Si A =! NULL 

        ENTONCES

A->INFORMACIÓN

           Llamar a RECURSIVIDAD con A->LIGA

9.- Fin FUNCION RESURSIVIDAD

10.-  Inicio FUNCION INSERTAR 

 B= A y BAND= VERDADERO

     mientras (B->INFORMACIÓN =! REF) y (BAND = VERDADERO)

              Si B -> LIGA =! NIL

                                              Entonces

                                                 T= B y B= B-> LIGA

                                              Else

                                                              BAND = FALSO

          Si BAND = VERDADERO entonces

                               (X)

                        X->INFORMACIÓN = DATO

                                              Si A = B

                                                             Entonces

                                                                             X ->LIGA = A y A = X

                                                             Else

                                                                             T ->LIGA =X y X ->LIGA = B

11.- Fin FUNCION INSERTAR

12.-Inicio FUNCION ELIMINAR

13.- B = A y BAND= VERDADERO

 mientras (B->INFORMACIÓN =! X) y  (BAND = VERDADERO)

                        Si B ->LIGA =! NULL

                Entonces

T = B y B = B -> LIGA

                               Else

BAND = FALSO

                         Si BAND = FALSO

               Entonces

                                              Imprimir  ”El elemento no fue encontrado”

                               Else

                          SI A = B  

               Entonces

                                A = B->LIGA

                                Else

                                                             T -> LIGA=B-> LIGA

14.- Fin FUNCION ELIMINAR

15.- Inicio CUERPO PRINCIPAL

16.-             Si ( P =! NULL)

                               Entonces

                     Si ( A ->INFORMACIÓN = X )

                                Entonces

               Imprimir   “El elemento se encuentra en la lista”

                                              Else

                BUSCARRECURSIVO con a -> LIGA y X

                                               Else

               Imprimir     “El elemento no se encuentra en la lista”

17.- Fin CUERPO PRINCIPAL

PILA Y COLA

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
#define MAX 100
char*p[MAX];
char*crecup(void);
void calmac (char*c);
void nombre(void);
int spos,rpos;
void intro (void),revisar(void),borrar(void);
int main(void)
{
char s[80];
register int t;
spos=0;
rpos=0;
for(t=0;t<MAX;++t)p[t]=NULL;
for(;;)
{
printf("\n(I)introducir\n(L)listar\n(B)borrar\n(N)nombre del programador\n(S)salir\n");
printf("\n\nEscribir tu accion a realizar:\n");
gets(s);
*s=toupper(*s);
switch(*s)
{
case 'I':intro();break;
case 'L':revisar();break;
case 'B':borrar();break;
case 'N':nombre();break;
case 'S':exit(0);
}
}
system("pause");
return 0;
}
void intro (void)
{
char s[100],*p;
do
{
printf("\nIntroduce todos tus datos deseados%d:\n",spos+1);
printf("(SOLO DA (ENTER) PARA REGRESAR AL MENU PRINCIPAL)");
gets(s);
if(*s=='\0')break;
p=(char*)malloc(strlen(s)+1);
if(!p)
{
printf("NO HAY MEMORIA RESERVADA\n");
return;
}
strcpy(p,s);
calmac(p);
}
while(*s);
}
void revisar(void)
{
int t;
if(rpos==spos)
{
printf("NO HAY DATOS\n");
return;
}
for(t=rpos;t<spos;t++)
printf("\n CADENA ES %d: %s\n",t+1,p[t]);
}
void borrar(void)
{
char*q;
q=crecup();
if(q==NULL)
{
printf("NO HAY DATOS!!!\n");
return;
}
printf("ESTE ES EL DATO RECUPERADO Y BORRADO: DATO NUMERO %d: %s\n",rpos+1,q);
free(q);
}
void nombre(void)
     {
          printf("\nRAMIREZ RAMIREZ VALERIA JUDITH");
           printf("\nMATRICULA: 1311120155 GRUPO: 110353\n\n");
     }
void calmac(char*q)
{
if(spos==MAX)
{
printf("\nLA COLA ESTA LLENA\n");
return;
}
p[spos]=q;
spos++;
}
char*crecup(void)
{
if(rpos==spos)
{
printf("\nNO HAY DATOS\n");
return NULL;
}
rpos++;
return p[rpos-1];
}

PALINDROMO

#define MAX 3
#include<stdio.h>
#include<conio.h>
#include<string.h>

void push(char i);
char pop(void);
int top=0;
char pila[MAX];


main()
{
int top=0;
char aux[MAX];
char original[MAX];
int x;
char a;

strcpy(aux,"");
for(x=0;x<MAX;x++){
fflush(stdin);
printf("Introduce una Letra=>");
scanf("%c",&a); 
push(a);  
}
printf("Pila:%s",pila);
strcpy(original,pila);

printf("\n\n%s\n%s",original,pila);

printf("\nValores POP\n");

for(x=0;x<3;x++)
{
aux[x]=pop();

}
printf("%d",strlen(aux));

if(strcmp(original,aux)==0)
printf("Palindromo");
else
printf("No es");

      getch();
      }

void push(char i)
{
     if(top>=MAX)
     {
                 printf("\nPila Llena\n\n");
                 return;             
                
                
                 }
     pila[top]=i;
     top++;
       
     }
char pop(void)
{
    top--;
    if(top<0)
    {
    printf("\nPila vacía\n");
    return(0);
             }
    return pila[top];
}

SUMA DE VECTORES

#include<conio.h>
#include<stdio.h>
#include<math.h>
struct vector
{
int j1,q,j2;
double ay,ax,resul,rx,ry,ang,by,bx;
};
struct vector vec[1];
main()
{
void seno(void);
printf("Dame vector:");
scanf("%d",&vec[1].j1);
printf("Dame vector:");
scanf("%d",&vec[1].j2);
printf("Dame el angulo:");
scanf("%d\n",&vec[1].q);
//seno
printf("________COSENO y SENO EN J2____________\n");
scanf("%d\n",&vec[1].q);
double a;
a=sin(vec[1].q);
printf("a=Sen(q); \n");
printf("%f\n\n",a);
vec[1].ay=(vec[1].j1)*a;
printf("ay=j1*a:\n ");
printf("%f\n\n",vec[1].ay);
//Coseno
double b;
b=cos(vec[1].q);
printf("b=cos(q); \n");
printf("%f\n\n",b);
vec[1].ax=(vec[1].j1)*b;
printf("ax=j1*b: \n");
printf("%f\n\n",vec[1].ax);
printf("______________________________________\n\n");
printf("________COSENO y SENO EN VECTOR____________\n");
//seno
vec[1].by=((vec[1].j2)*a);
printf("by=j2*a: \n");
printf("%f\n\n",vec[1].by);
//coseno
vec[1].bx=((vec[1].j2)*b);
printf("bx=j2*b: \n");
printf("%f\n\n",vec[1].bx);
printf("______________________________________\n\n");
printf("___________SUMA DE VECTORES___________\n");
vec[1].rx=vec[1].ax+vec[1].bx;
printf("rx=ax+bx: \n");
printf("%f\n\n",vec[1].rx);
vec[1].ry=vec[1].ay+vec[1].by;
printf("ry=ay+by: \n");
printf("%f\n\n",vec[1].ry);
printf("______________________________________\n\n");
printf("___________RESULTANTE DE LOS VECTORES___________\n");
double j1,j2;
j1=(vec[1].rx)*(vec[1].rx);
printf("(rx)*(rx): %f\n",j1);
j2=(vec[1].ry)*(vec[1].ry);
printf("(ry)*(ry):%f \n",j2);
vec[1].resul=sqrt(j1+j2);
printf("Resultante de los vectores; %f\n",vec[1].resul);
printf("______________________________________\n\n");
printf("___________ANGULOS DE LOS VECTORES___________\n");
double rf,nn;
nn=vec[1].ry/vec[1].rx;
printf("Division y/x: : %f\n",nn);
vec[1].ang= atan(nn);
printf("Angulo Radianes: %f\n",vec[1].ang);
rf=(180*vec[1].ang)/(3.141592654);
printf("La convercion es: %f\n",rf);
getch();
}

PAR E IMPAR

#include <stdio.h>
#include <conio.h>
void datos (void);
main()
{
int x,sp=0,si=0,st;
float prom,y;
int n[10];
for (x=0;x<10;x++)
{
printf("Escribe el numero: %d\n",x+1);
scanf("%d", & n[x]);
}
for(x=0;x<10;x++)
{
if(n[x]%2==0)
sp=sp+n[x];
else
si=si+n[x];
}
y=sp+si;
printf("El total de los numeros pares es de: %d\n", sp);
printf("El total de los numeros impares es de:%d\n", si);
printf("La suma de todos los numeros es de: %.2f\n", y);
void datos (void);
{
printf("Nombre:Silvia Brenda Tobon Amaro\n");
printf("Grupo:353\n");
}
getch();
}

PROMEDIO

#include<conio.h>
#include<stdio.h>
float g;
int a,b,c,d,e;
int promedio(int x,int y,int z,int w,int j);
main ()
{
printf("Dame un numero \n");
scanf("%d",&a);
printf("Dame un numero \n");
scanf("%d",&b);
printf("Dame un numero \n");
scanf("%d",&c);
printf("Dame un numero \n");
scanf("%d",&d);
printf("Dame un numero \n");
scanf("%d",&e);
g=promedio(a,b,c,d,e);
printf("resultado = %f \n",g);
getch();
}
int promedio(int x,int y,int z,int w,int j)
{
return((x+y+z+w+j)/5);
}