Busqueda Binaria

#include<stdio.h>
main()
{
 int i, num[10]={1,2,3,11,12,13,15,17,21,22}, bus;
 printf("que numero desea buscar\n");
 scanf("%i", & bus);
 i=10/2;
 if(bus==num[i])
 {
  printf("el numero fue encontrado en la posicion %i", i);
 }
 else
 {
  if(bus<num[i])
  {
   for(i=4;bus<=num[i];i--)
   {
    if(num[i]==bus)
    {
     printf("el numero fue encontrado en la posicion %i", i);
     goto salida;
    }
   }
  }
  if(bus>num[i])
  {
   for(i=6;bus>=num[i];i++)
   {
    if(num[i]==bus)
    {
     printf("el numero fue encontrado en la posicion %i", i);
     goto salida;
    }
   }
  }
 }
 if(num[i]!=bus)
 {
  printf("el numero no se encuentra en el arreglo\n");
 }
 salida:
  printf("\nPulse una tecla para continuar");
  getch();
 return 0;
}

Busqueda Secuencial (Elementos en Orden)

#include<stdio.h>
main()
{
 int num[10]={1,2,4,6,8,10,34,35,46,57};
 int i, var;
 printf("que numero desea buscar\n");
 scanf("%i", & var);
 for(i=0; var>=num[i]; i++)
 {
  if(num[i]==var)
  {
   printf("el numero se encontro en la posicion %i\n", i);
   goto salida;
  }
 }
 if(num[i]!=var)
  {
   printf("el numero no se encuentra en el arreglo\n");
  }
 salida:
  printf("pulsa una tecla para continuar");
  getch();
}

Busqueda Secuencial (Elementos en Desorden)

#include<stdio.h>
main()
{
 int num[10]={10,23,12,1,2,5,65,4,22,9};
 int i, var;
 printf("que numero desea buscar\n");
 scanf("%i", & var);
 for(i=0; i<=9; i++)
 {
  if(num[i]==var)
  {
   printf("el numero se encontro en la posicion %i\n", i);
   goto salida;
  }
 }
 if(num[i]!=var)
  {
   printf("el numero no se encuentra en el arreglo\n");
  }
 salida:
  printf("Pulse una tecla para continuar");
  getch();
}

Metodos de Ordenamiento "Quicksort"

#include <stdio.h>
 
 void qs(int lista[],int limite_izq,int limite_der)
 {
     int izq,der,temporal,pivote;
 
     izq=limite_izq;
     der = limite_der;
     pivote = lista[(izq+der)/2];
 
     do{
         while(lista[izq]<pivote && izq<limite_der)izq++;
         while(pivote<lista[der] && der > limite_izq)der--;
         if(izq <=der)
         {
             temporal= lista[izq];
             lista[izq]=lista[der];
             lista[der]=temporal;
             izq++;
             der--;
 
         }
 
     }while(izq<=der);
     if(limite_izq<der){qs(lista,limite_izq,der);}
     if(limite_der>izq){qs(lista,izq,limite_der);}

 }
 
 void quicksort(int lista[],int n)
{
     qs(lista,0,n-1);
 }
 
 int main(int argc, const char * argv[])
 {
  system("COLOR 1F");
  system("TITLE QUICKSORT");
     int lista[10];
     int size = sizeof(lista)/sizeof(int);
  int i;
  for (i=0;i<=9;i++)
  {
   printf("\ndame un numero para asignarlo a la posocion numero %i:\n", i+1);
   scanf("%i", & lista[i]);
  }
  printf("el arreglo tiene los siguientes valores:\n");
  for(i=0;i<=9;i++)
  {
   printf("%i |", lista[i]);
  }
  printf("\npulse una tecla para continuar");
  getch();
     printf("\n");
     quicksort(lista,size);
  printf("el arreglo tiene los siguientes valores:\n");
  for(i=0;i<=9;i++)
  {
   printf("%i |", lista[i]);
  }
  printf("\npulse una tecla para continuar");
  getch();
     return 0;
 }

Metodos de Ordenamiento "Shell Sort"

#include<stdio.h>
main()
{
 int num[10], j, i, aux, k, n=10;
 for (i=0;i<=9;i++)
 {
  printf("\ndame un numero para asignarlo a la posocion numero %i:\n", i+1);
  scanf("%i", & num[i]);
 }
 printf("el arreglo tiene los siguientes valores:\n");
 for(i=0;i<=9;i++)
 {
  printf("%i |", num[i]);
 }
 printf("\npulse una tecla para continuar");
 getch();
 k=n/2;
 while(k>=1)
 {
  for(i=k;i<n;i++)
  {
   aux=num[i];
   j=i-k;
   while(j>=0 && num[j]>aux)
   {
    num[j+k]=num[j];
          j-=k;
   }
   num[j+k]=aux;
  }
  n=n/2;
 }
 printf("el arreglo tiene los siguientes valores:\n");
 for(i=0;i<=9;i++)
 {
  printf("%i |", num[i]);
 }
 printf("\npulse una tecla para continuar");
 getch();
}

Metodos de Ordenamiento "Selección Directa"

#include<stdio.h>
main()
{
int num[10];
int i, aux, j, min;
for (i=0;i<=9;i++)
 {
  printf("\ndame un numero para asignarlo a la posocion numero %i:\n", i+1);
  scanf("%i", & num[i]);
 }
 printf("el arreglo tiene los siguientes valores:\n");
 for(i=0;i<=9;i++)
 {
  printf("%i |", num[i]);
 }
 printf("\npulse una tecla para continuar");
 getch();
for(i=0; i<9; i++)
{
 min=num[i];
 for(j=i+1; j<10; j++)
 {
  if (num[j]<num[min])
  {
   min=j;
  }
 }
 aux=num[i];
 num[i]=num[min];
 num[min]=aux;
}
printf("el arreglo tiene los siguientes valores:\n");
 for(i=0;i<=9;i++)
 {
  printf("%i |", num[i]);
 }
 printf("\npulse una tecla para continuar");
 getch();
}

Metodos de Ordenamiento "Piedra-Intercambio Inverso"

#include<stdio.h>
main()
{
int num[10];
int i, aux, j;
for (i=0;i<=9;i++)
 {
  printf("\ndame un numero para asignarlo a la posocion numero %i:\n", i+1);
  scanf("%i", & num[i]);
 }
 printf("el arreglo tiene los siguientes valores:\n");
 for(i=0;i<=9;i++)
 {
  printf("%i |", num[i]);
 }
 printf("\npulse una tecla para continuar");
 getch();
for(j=9; j>0; j--)
{
 for(i=0; i<j; i++)
 {
  if (num[i]>num[i+1])
  {
   aux=num[i];
   num[i]=num[i+1];
   num[i+1]=aux;
  }
 }
}
printf("el arreglo tiene los siguientes valores:\n");
 for(i=0;i<=9;i++)
 {
  printf("%i |", num[i]);
 }
 printf("\npulse una tecla para continuar");
 getch();
}

Metodos de Ordenamiento "Burbuja"

 

#include<stdio.h>
main()
{
int num[10];
int i, aux, j;
for (i=0;i<=9;i++)
 {
  printf("\ndame un numero para asignarlo a la posocion numero %i:\n", i+1);
  scanf("%i", & num[i]);
 }
 printf("el arreglo tiene los siguientes valores:\n");
 for(i=0;i<=9;i++)
 {
  printf("%i |", num[i]);
 }
 printf("\npulse una tecla para continuar");
 getch();
for(j=0; j<9; j++)
{
 for(i=9; i>j; i--)
 {
  if (num[i]<num[i-1])
  {
   aux=num[i];
   num[i]=num[i-1];
   num[i-1]=aux;
  }
 }
}
printf("el arreglo tiene los siguientes valores:\n");
 for(i=0;i<=9;i++)
 {
  printf("%i |", num[i]);
 }
 printf("\npulse una tecla para continuar");
 getch();
}

Metodos de Ordenamiento "Insercion Directa"

#include <stdio.h>//metodo inverso
int num[10]={10,4,20,32,59,3,49,12,14,1};
int i,aux,j;
main()
{printf("\nEl arreglo original es:\n");
for(i=0;i<=9;i++)
 {
printf("%d,",num[i]);
printf("\n");
 }
 getch();

for (i=1;i<=9;i++)
  {
  aux=num[i];
  j=i-1;
  while (aux<num[j]||j==0)
  {num[j+1]=num[j];
  j--;
  }
  num[j+1]=aux;
 }
 printf("\nEl arreglo ordenado es:\n");
for(i=0;i<=9;i++)
 {
 printf("%d,",num[i]);
 printf("\n");
 }getch();
}

Metodos de Ordenamiento "Shaker Sort"

#include<stdio.h>
#include<conio.h>
main ()
{
 int num [10], i, j, aux, a;
 for (i=0; i<=9; i++)
 {
 printf("\nIngresa el valor de la posicion %d: ", i+1);
 scanf("%i", &num[i]);
 }
 getch();
 for (j=-1; j<=10; j++)
 {
 for (i=10; i>j; i--)
  {
   if (num [i]<num[i-1])
   {
   aux = num[i];
   num[i] = num[i-1];
   num[i-1] = aux;
   }
    for (i=10; i>j; i--)
  {
   if (num [i]>num[i+1])
   { 
    aux = num[i];
    num[i] = num[i+1];
    num[i+1] = aux;
   }

  }

  }
 }
 printf("\n El arreglo ordenado es:\n");
 for (i=0; i<=9; i++)
 printf("%i | ", num[i]);

 return 0;
 getch ();
}

Árbol-Programación en C

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
struct arbol {
       struct arbol *izq;
       int clave;
       struct arbol *der; };
typedef struct arbol ARB;
typedef ARB *ARBPT;
void inserta(ARBPT *, int);
void menu(void);
void preorden(ARBPT);
void busqueda(ARBPT, int);
main()
{ ARBPT raiz = NULL;
  int opcion, clav;
  menu();
  fflush(stdin);
  printf("\n                Elige opcion: ");
  scanf("%d", &opcion);
  while (opcion != 4) {
 switch(opcion)
 { case 1 : printf("\n                Digita la clave del nodo : ");
         scanf("%d", &clav);
         inserta(&raiz, clav)     ;
         break;
   case 2 : printf("\n\n                Recorrido del arbol en PREORDEN\n\n");
         printf("\n                ");
         preorden(raiz);
         printf("\n\n                Enter para continuar...");
         getch();
         break;
   case 3 : printf("\n                Digita la clave del nodo que quieres buscar : ");
         scanf("%d", &clav);
         busqueda(raiz, clav)     ;
         getch();
      break;    
   default : printf("\n\n                Opcion no permitida.\n\n");
             printf("\n\n                Enter para continuar...\n\n");
             getch();
          menu();
 }
 menu();
 fflush(stdin);
 printf("\n                Elige opcion: ");
 scanf("%d", &opcion);
     }
     printf("\n                Fin del programa.\n\n");
     printf("\n                Enter para terminar...");
     getch();
}
void menu(void)
     { system("cls");
       printf("\n\n\n\n"
       "              OPERACIONES DISPONIBLES CON EL ARBOL: \n\n\n\n"
       "              1 INSERTAR UN ELEMENTO AL ARBOL\n\n"
       "              2 RECORRER EL ARBOL EN PREORDEN\n\n"
                        "              3 BUSQUEDA EN EL ARBOL\n\n"
       "              4 SALIR DEL PROGRAMA\n\n");
     }
void inserta(ARBPT *raiz, int cla)
{ ARBPT aux1, aux2, aux3= NULL;
  aux1 = (struct arbol *) malloc(sizeof(struct arbol));
  if (aux1 != NULL)
     {aux1->clave = cla;
      aux1->izq = NULL;
      aux1->der = NULL;
      aux2 = *raiz;
      while (aux2 != NULL)
      {aux3 = aux2;
       if (cla == aux2->clave)
   { printf("\n\n                 Clave del nodo duplicado\n");
     printf("                 No insertado\n");
     printf("                 Enter para continuar");
     getch();
     goto salida;
   }
       if (cla < aux2->clave)
    aux2 = aux2->izq;
       else
    aux2 = aux2->der;
      }
      if (aux3 == NULL)
   *raiz = aux1;
      else
   { if (cla == aux3->clave)
        { printf("\n\n                 Clave del nodo duplicado\n");
   printf("                 No insertado\n");
   printf("                 Enter para continuar");
   getch();
   goto salida;
        }
     if (cla < aux3->clave)
  aux3->izq = aux1;
     if (cla > aux3->clave)
        aux3->der = aux1;
   }
     }
  else
     { printf("\n                Nodo no insertado" );
       printf("\n                No hay memoria disponible\n\n");
       printf("\n                Emter para continuar...");
       getch();
     }
     salida:
            printf("\n               Enter para menu....");
            getch();
}
void preorden(ARBPT ap1)
{ ARBPT ap2;
  if(ap1 != NULL)
  { printf("\n raiz = %2d ", ap1->clave);
    ap2 = ap1->izq;
    if (ap2 != NULL)
       printf(" izquierdo : %2d", ap2->clave);
    else printf(" izquierdo NULO");
    preorden(ap2);
    ap2= ap1->der;
    if (ap2 != NULL)
       printf(" derecho : %2d", ap2->clave);
    else printf(" derecho NULO");
    preorden(ap2);
  }
}
void busqueda(ARBPT ap1, int clav)
{
 if(ap1==NULL)
 {
 printf("\nodo no encontrado!");
 }
 else
 {
  while(ap1!=NULL)
  {
   printf("\nRaiz:%i",ap1->clave);
   if(ap1->clave==clav)
   {
    printf("\n\nNodo encontrado:%i",ap1->clave);
    ap1=NULL;
   }
   else
   {
    if(clav < ap1->clave )
    {
     ap1=ap1->izq;
     printf("Izquierdo: %i",ap1->clave);
    }
    else
    {
     ap1=ap1->der;
     printf("Derecho: %i",ap1->clave);
    }
   }
  }
 }
}

 

Lista Ordenada

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

struct lista {
       int clave;
       char descrip[25];
       struct lista *sigptr; };
typedef struct lista LISTA;
typedef LISTA *LSTPTR;

void imprime(LSTPTR auxptr)/*auxptr ya apunta al inicio de la lista porque en el llamado de la función se le esta
pasando el valor de iniptr*/
{
    if(auxptr==    NULL)
    {
        printf("\nno hay lista");
    }
    else
    {
        while(auxptr!=NULL)
        {
            printf("|<  %d, %s", auxptr->clave, auxptr->descrip);
           auxptr=auxptr->sigptr;
        }
    }
    getch();
}
void enlista(LSTPTR *iniptr/*iniptr que apunta  al inicio de la lista y tiene la direccion de memoria de iniptr
 que se encuentra en main*/, LSTPTR *finptr, int cla, char descr[25])
{ LSTPTR nvoptr, actptr, otroptr;
  nvoptr = (LSTPTR) malloc(sizeof(LISTA));// a nvo ptr se le asigna un espacio en memoria del tamaño de la estrucutura lista
  if (nvoptr != NULL)//preguntar si se reservo el espacio
     {nvoptr->clave = cla;//el valor de cla, valor solicitado en el main, sera asignado al miembro clave que esta siendo apuntado por nvoptr
      strcpy(nvoptr->descrip, descr);//se copia la cadena descr que se encuentra en main hacia descrip que es miembro del nodo
      nvoptr->sigptr = NULL;//asignar valor nulo al miembro sigptr que esta siendo apuntado por nvoptr
      if (*iniptr == NULL)//si la variable que esta siendo apuntada por iniptr o sea iniptr del main es nula
     {*iniptr/*la variable que esta siendo apuntada por iniptr o sea iniptr del main*/ = nvoptr;//al iniptr del main se le asigna la direccion de nvoptr o sea el nodo completo
      *finptr = nvoptr;//al finptr del main se le asigna la direccion de nvoptr o sea el nodo completo
     }
      else
     {actptr = *iniptr;//asignar el valor de la variable que esta siendo apuntada por iniptr al apuntador actptr
      if (cla < (*iniptr)->clave)//si cla es menor que clave, y clave esta siendo apuntada por actptr aunque se tiene q referir a iniptr
        {nvoptr->sigptr = *iniptr;
         *iniptr = nvoptr;
        }
     else
        if (cla > (*finptr)->clave)//si cla es mayor que la variable clave del main
           {(*finptr)->sigptr = nvoptr;//el valor de la variable nvoptr va a ser asiganado a sigptr que esta siendo apuntada por la variable q esta siendo apuntada por finptr
        *finptr = nvoptr;//el valor de nvoptr sera asignado a finptr
           }
        else
           {otroptr = actptr->sigptr;//a otroptr se el asigna el valor de sigptr que esta siendo apuntada por actptr
        while (cla > otroptr->clave)//mientras que cla sea mayor que clave que esta siendo apuntado por otroptr
              {actptr= actptr->sigptr;//el valor del miembro sigptr que esta siendo apuntado por actptr, se asigna a actptr
               otroptr= actptr->sigptr;
              }
        actptr->sigptr = nvoptr;
        nvoptr->sigptr = otroptr;
           }
     }
     }
  else
      printf("%d no fue insertado. No hay memoria disponible\n\n", cla);
}

void menu(void)
     { system("cls");
       printf("\n\n\n\n"
          "              OPERACIONES DISPONIBLES EN LA LISTA ORDENADA: \n\n\n\n"
          "              1 AGREGAR UN ELEMENTO A LA LISTA\n"
          "              2 IMPRIMIR LA LISTA\n"
          "              3 EXTRAER UN ELEMENTO DE LA LISTA\n"
          "              4 SALIR DEL PROGRAMA\n");
     }

main()
{ LSTPTR iniptr = NULL/*apuntador al inicio de la lista*/, finptr = NULL/*apuntador al final de la lista*/;
  char opcion, descri[25];//variables para capturar los datos solicitados
  int clav;//datos solicitados
  menu();
  printf("\n                Elige opcion: ");
  scanf("%c", &opcion);
  while (opcion != '4')
        { switch(opcion)
                { case '1': printf("\n                Clave del articulo (entero): ");
                            scanf("%d", &clav);
                            fflush(stdin);
                            printf("\n                  Descripcion del articulo : ");
                            gets(descri);
                            enlista(&iniptr/*parametro q pasa la direccion de memoria del apuntador del inicio de la lista a la función enlista*/, &finptr, clav, descri)           ;//funcio para insertar a la lista
                            break;
                  case '2': imprime(iniptr);
                              break;
                  /*case '3': extrae(&iniptr,&finptr,clav);
                              break;*/
                  default : printf("\n\n Opcion no valida.....");
                            printf("\n\n Enter para continuar...");
                            getch();
                            break;
                }
          menu();
          fflush(stdin);
          printf("\n                Elige opcion: ");
          scanf("%c", &opcion);
        }
  printf("\n                Fin del programa.\n\n");
  printf("                Enter para terminar...");
  getch();
}

Colas

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

struct colanodo {
       int clave;
       char descrip[20];
       struct colanodo *sigptr;};//apuntador del tipo estructura colanodo

typedef struct colanodo COLANODO;
typedef COLANODO *COLANODOPTR;

void enqueue(COLANODOPTR *, COLANODOPTR *, int, char[]);//se pone el asterisco porque
void menu(void);
void imprime(COLANODOPTR);
void dequeue(COLANODOPTR *);

main()
{ COLANODOPTR adelaptr = NULL/*apuntador al inicio de la cola*/, atrasptr = NULL/*final de la cola*/;
  int opcion, clav;
  char descri[20];
  menu();//llamada al funcion menu
  printf("\n                Elige opcion: ");
  scanf("%d", &opcion);

  while (opcion != 4)
        { switch(opcion)
                { case 1: printf("\n                INSERCION EN LA COLA");  
                          printf("\n\n                Clave del articulo:  ");
                          scanf("%d", &clav);
                          fflush(stdin);
                          printf("\n          Descripcion del articulo:  ");
                          gets(descri);
                          enqueue(&adelaptr, &atrasptr, clav, descri);
                          break;
                  case 2:
                                dequeue (&adelaptr);
                  break;
                  case 3:
                                imprime (adelaptr);
                  break;
                          //llamado de la función imprime: imprime(adelaptr);
                  default : printf("\n                Opcion no permitida.\n\n");
                            printf("                Enter para continuar...");
                            getch();
                            menu();
                            break;
                }
          menu();
          printf("\n                Elige opcion: ");
          scanf("%d", &opcion);
        }
  printf("\n                Fin del programa.\n\n");
  printf("\n                Enter para salir...");
  getch();
}

void menu(void)
     { system("cls");
       printf("\n\n\n\n"
          "              OPERACIONES DISPONIBLES CON LA COLA: \n\n\n\n"
          "              1 (enqueue) AGREGAR UN DATO A LA COLA\n"
          "              2 (dequeue) ELIMINAR UN DATO DE LA COLA\n"
          "              3 IMPRIMIR LA COLA\n"
          "              4 SALIR DEL PROGRAMA\n");
     }

void enqueue(COLANODOPTR *adelaptr/*se declara un apuntador, al apuntador *adelaptr de la función main*/,
COLANODOPTR *atrasptr/*apuntador que apunta a *atrasptr de la función main*/, int cla, char desc[20])
     { COLANODOPTR nvoptr;
       nvoptr = (COLANODOPTR) malloc(sizeof(COLANODO));//se le asigna un espacio en memoria del tamaño de colanodo
       if (nvoptr != NULL) {
       nvoptr->clave = cla;//el miembro clave que esta siendo apuntado por nuevoptr asignale el valor de cla
       strcpy(nvoptr->descrip, desc);/*en la función para copiar string: en la cadena desc vamos a copiar lo que hay en descrip
       que esta siendo apuntada por nvoptr*/
       nvoptr->sigptr = NULL; /* a sigptr que se encuentra en cada elemento de la cola, que esta siendo apuntado por nvoptr
        le asignamos un valor nulo*/
       if (*adelaptr==NULL)//if para agregar el primer nodo de la cola
           *adelaptr = nvoptr;
       else//si ya hay un elemento(S) en la cola los nuevos se van formando atras/* entonces se entra al else*/
          (*atrasptr)->sigptr = nvoptr;/*el valor de nvoptr se lo asignamos a sigptr que esta siendo apuntado
           por la variable que esta siendo apuntada por atrasptr<el ultimo elemento que fue ingresado es apuntado por atrasptr
           del main, entonces ordenamos que el apuntador en ese nodo apunte hacia la posición de arriba>*/
       *atrasptr = nvoptr;/*al cumplirse cualquiera de las condiciones anteriores el valor de nuevoptr es asignado al atrasptr
       del main para reconocerlo como el nuevo final de la cola*/
       }
       else//else del if principal que nos indica que no se encontro memoria disponible
      printf("%c %s no fue insertado. No hay memoria disponible\n\n", cla, desc);
       }
void imprime(COLANODOPTR auxptr)
{
    if(auxptr==NULL)
    printf("no hay cola\n");
    else
    {
        while(auxptr!=NULL)
        {
            printf("\n %d %s", auxptr->clave, auxptr->descrip);
             auxptr= auxptr->sigptr;
        }
        printf("\nfin de la cola");
    }
    getch();
}
void dequeue(COLANODOPTR *adelaptr)
{
    COLANODOPTR auxptr;
    auxptr=*adelaptr;
    if(auxptr==NULL)
    {
        printf("\n no hay elementos en la cola");
    }
    else
    {
        (*adelaptr)=auxptr->sigptr;
        printf("\n el producto de clave: %i-- y descripcion: %s fue eliminado",auxptr->clave, auxptr->descrip);
        free(auxptr);
    }
    getch();
}