PROGRAMAS DE BUSQUEDA

EN ESTE EJEMPLO SE REALIZA LA BUSQUEDA DEL PRMEDIO MAS ALTO , EN UNA SERIE DE ALUMNOS, MEDIANTE EL IMPLEMENTO DE ARREGLOS BIDIMENSIONALES

#include<conio.h>
#include<iostream.h>

void main()
{
clrscr();
char nombre[10][5];
int cal[3][5];
int suma;
float prom[5];
int i,j,k;
float mayor=0,aux;


for(i=0;i<5;i++){
suma=0;
    cout<<"Introduze el nombre:"<<endl;
    cin>>nombre[i];
       
   for(j=0;j<3;j++){
    
        cout<<"calificacion"<<endl;
           cin>>cal[i][j];
       
       suma=suma+cal[i][j];
      
       }
       prom[i]=suma/3;
cout<<nombre[i]<<endl;
           cout<<"promedio"<<prom[i]<<endl;

}
for(i=0;i<5;i++){

if(prom[i]>=mayor)
{
mayor=prom[i];
aux=i;
}
}
cout<<"el nombre del alumno es:"<<nombre[aux]<<"  su promedio es:"<<prom[aux]<<endl;

getch();
}

PROGRAMAS DE BUSQUEDA

ESTE PROGRAMA NOS EFECTUA UNA BUSQUEDA DE LA CALIFICACION MAYOR A 8 DE UNA SERIE DE ALUMNOS,IMPLEMENTANDO ARREGLOS UNIDIMENSIONALES

#include<conio.h>
#include<iostream.h>

void main()
{
clrscr();
char nombre[10][5];
int cal[5];

for(int i=0;i<5;i++){
    cout<<"Introduze el nombre:"<<endl;
    cin>>nombre[i];
        cout<<"calificacion"<<endl;
        cin>>cal[i];
}
for(int j=0;j<5;j++){
    if(cal[j]>=8)
        cout<<"Nombre del alumno"<<":"<<nombre[j]<<"  su calificacion"<<":"<<cal[j]<<endl;
}
getch();
}

PROMAGRA RECURSIVO

ESTE EJEMPLO NOS IMPRIME UNA CADENA DE CARACTERES MEDIANTE EL USO DE RECUSRIVIDAD

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

void main()
{
char enunciado[80];
void reversa(char *);

clrscr();

printf("\n\nEscribe un enunciado:\n");
gets(enunciado);

printf("\n\nEl enunciado al reves:\n");
reversa(enunciado);

getch();
}

void reversa(char *s)
{
if(s[0] == '\0')
return;
else
{
reversa(&s[1]);
putchar(s[0]);
}
}

PROGRAMA CON FUNCIONES

ESTE EJEMPLO CALCULA EL FACTORIAL

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

int f(int n)

 {
   if (n==0)
   return 1;
   else
return f(n-1)+pow(2,n);

}
int main()
{
clrscr();
int x;
int fac;

printf("ingrese un numero para calcular la funcion: \n");
scanf("%d",&x);

fac=f(x);

printf("%d = %d\n",x,fac);
getch();
return 0;

}

RECORRIDO DE LOS ARBOLES BINARIOS

RECORRIDO EN ARBOLES BINARIOS

Una de las operaciones mas importantes a realizar en un árbol binario es el recorrido de los mismos, recorrer significa visitar los nodos del árbol en forma sistemática, de tal manera que todos los nodos del mismo sean visitados una sola vez.

Existen 3 formas diferentes  de efectuar el recorrido y todas ellas de naturaleza recursiva, estas son:

RECORRIDO PREORDEN: En el que se procesa el nodo y después se procesan recursivamente sus hijos.

RECORRIDO POSTORDEN: Donde el nodo dado se procesa después de haber procesado recursivamente a sus hijos.

RECORRIDO INORDEN: En este se procesa recursivamente el hijo izquierdo, luego se procesa el nodo actual y finalmente se procesa  recursivamente el hijo derecho.

Hay un último recorrido que implementa a estos 3.

RECORRIDI POR NIVELES: Este recorrido procesa los nodos comenzando en la raíz y avanzando de forma descendente y de izquierda a derecha.

RECORRIDO PREORDEN

• VISITAR LA RAIZ
• RECORRER EL SUBARBOL IZQUIERDO
• RECORRER EL SUBARBOL DERECHO

Recorrido en preorden: consiste en visitar el nodo actual (visitar puede ser simplemente mostrar la clave del nodo por pantalla), y después visitar el subárbol izquierdo y una vez visitado, visitar el subárbol derecho. Es un proceso recursivo por naturaleza.

                                           PREORDEN: A-B-D-E-C-F-G

ALGORITMO

El algoritmo realiza el recorrido preorden en un árbol binario.

NODO es un dato de tipo puntero.

INFO, IZQ y DER son campos del registro nodo.

INFO es una variable de tipo carácter, IZQ y DER son variables de tipo puntero.

1. si NODO ≠ NULL

entonces

      Visitar  el NODO { Escribir NODO^.INFO}

      Regresar a PREORDEN con NODO^.IZQ

      {Llamada recursiva a preorden  con la rama izquierda del nodo en cuestión}

     Regresa a PREORDEN  con NODO^.DER

     {Llamada recursiva a preorden  con la rama derecha del nodo en cuestión}

2. Fin del condicional del paso I

CODIGO

void preorden(tArbol *a)

{

  if (a != NULL) {

    Visitar(a);             //Realiza una operación en nodo

    preorden(a->hIzquierdo);

    preorden(a->hDerecho);

  }

}

COMO FUNCIONAN LOS BUSCADORES WEB

Los buscadores de antes

Los buscadores anteriores a Google (salvo Altavista), eran directorios de páginas web. Esto significa lo siguiente:

- Tú debías dar de alta tu página web en el directorio del buscador.

- Debías indicar cuales eran las palabras clave por las que deseabas ser encontrado.

- Tú redactabas la definición de tu página web.

... Y cuando alguien buscaba una palabra que estaba incluida en tus palabras clave o en tu definición, el buscador consultaba su lista de páginas web y mostraba tu página.

Cómo funcionan ahora los buscadores

Ahora son índices automáticos de páginas web:

1.- Una araña visita tu página web.

2.- La araña lee el contenido de tu página web.

3.- La araña lleva toda la información a una central, donde un sistema la procesa y la almacena.

4.- El sistema crea un índice con las palabras que utilizas en tu web y las ordena por relevancia. (Ver ejemplo de índice de palabras)

5.- El sistema intenta descubrir si eres una buena página o no (en realidad comprueba cuanta gente recomienda tu web y cuan importante es la gente que recomineda tu web).

6.- Cuando alguien realiza una búsqueda, y el sistema muestra todas las webs que contienen la palabra o frase buscada.

... Y muestra los resultados en función de un algoritmo de ordenación que tiene en cuenta la importancia de la página web y la importancia del término buscado, en esa página web.

Las arañas o robots

Hay muchísimas arañas navegado constantemente por la red. La mayor parte de las que visitan tu web, pertenecen a buscadores. Pero cualquiera puede programar una araña y enviarla por ejemplo, a buscar todos los emails que encuentre, o todas las referencias a un producto determinado, etc.

Controlando las 6 principales arañas de los buscadores, tenemos controladas al 90% de las arañas que nos interesan:

- Google Bot (Google)

- Slurp (Yahoo)

- MSNBot (Microsoft)

- Scooter (Altavista)

- Fast (webs privadas)

- Teoma (Ask Jeeves)

CODIGO FUENTE DE TORRES DE HANÓI EN C MEDIANTE RECURSIVIDAD

Mediante recursividad

Este problema se suele plantear a menudo en ámbitos de programación, especialmente para explicar la recursividad. Si numeramos los discos desde 1 hasta n, y llamamos X a la primera pila de discos (origen), Z a la tercera (destino) e Y a la intermedia (auxiliar) y a la función le llamaríamos hanói (origen, auxiliar, destino), como parámetros, la función recibiría las pilas de discos. El algoritmo de la función sería el siguiente:

   1. Si origen == {0}: mover el disco 1 de pila origen a la pila destino (insertarlo arriba de la pila destino); terminar.

   2. Si no: hanoi({0...n-1},destino, auxiliar)     //mover todas las fichas menos la más grande (n) a la varilla auxiliar

   3. Mover disco n a destino                //mover la ficha grande hasta la varilla final

   4. Hanoi (auxiliar, origen, destino)          //mover todas las fichas restantes, {0...n-1}, encima de la ficha grande (n)

   5. Terminar


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

void hanoi(int n,int com, int aux, int fin);

void main(void){

        clrscr();
    char com='A';
    char aux='B';
    char fin='C';
    int n;

    printf("\nN£mero de discos: ");
    scanf("%d",&n);
    fflush(stdin);

    printf("\n\nLos movimientos a realizar son: \n");
    hanoi(n,com,aux,fin);
}

void hanoi(int n,int com, int aux, int fin){

    if(n==1){
        printf("%c->%c",com,fin);
    }
    else{
        hanoi(n-1,com,fin,aux);
        printf("\n%c->%c\n",com,fin);
        hanoi(n-1,aux,com,fin);
getch();
    }
}

TORRES DE HANÓI

Las Torres de Hanói es un rompecabezas o juego matemático inventado en 1883 por el matemático francés Éduard Lucas. Este solitario  se trata de un juego de ocho discos de radio creciente que se apilan insertándose en una de las tres estacas de un tablero. El objetivo del juego es crear la pila en otra de las estacas siguiendo unas ciertas reglas. El problema es muy conocido en la ciencia de la computación y aparece en muchos libros de texto como introducción a la teoría de algoritmos.

El juego, en su forma más tradicional, consiste en tres varillas verticales. En una de las varillas se apila un número indeterminado de discos (elaborados de madera) que determinará la complejidad de la solución, por regla general se consideran ocho discos. Los discos se apilan sobre una varilla en tamaño decreciente. No hay dos discos iguales, y todos ellos están apilados de mayor a menor radio en una de las varillas, quedando las otras dos varillas vacantes. El juego consiste en pasar todos los discos de la varilla ocupada (es decir la que posee la torre) a una de las otras varillas vacantes. Para realizar este objetivo, es necesario seguir tres simples reglas:

   1. Sólo se puede mover un disco cada vez.

   2. Un disco de mayor tamaño no puede descansar sobre uno más pequeño que él mismo.

   3. Sólo puedes desplazar el disco que se encuentre arriba en cada varilla.

RECURSIVIDAD

RECURSIVIDAD: tanto en el ámbito informático y matemático, cuando definimos algo (un tipo de objeto, una propiedad o una operación) en función de si misma, es sencillo, útil y potente.

RECURSIVIDAD DIRECTA: cuando un subprograma se llama así mismo una o más veces directamente.

RECURSIVIDAD INDIRECTA: cuando se definen una serie de subprogramas usándose unos a otros.

La recursividad nos sirve en la vida diaria, en problemas matemáticos, en estructuras de datos y en muchos otros problemas.

VENTAJAS DE LA RECURSIVIDAD: la principal ventaja es la simplicidad de comprensión y su gran potencia, favoreciendo la resolución de problemas de manera natural, sencilla y elegante; y facilidad para comprobar y convencerse de que la solución del problema es correcta.

DESVENTAJAS DE LA RECURSIVIDAD: la principal desventaja tanto en tiempo como en memoria, dado que para permitir su uso es necesario transformar el programa recursivo en otro iterativo, que utiliza pilas y bucles para almacenar las variables.