Recorrido de Árboles...

- Recorridos en profundidad:

* 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.

Si se hace el recorrido en preorden del árbol de la figura 1 las visitas serían en el orden siguiente: a,b,d,c,e,f.

void preorden(tarbol *a)

{

  if (a != NULL) {

    visitar(a);

    preorden(a->izq);

    preorden(a->der);

  }

}

* Recorrido en inorden u orden central: se visita el subárbol izquierdo, el nodo actual, y después se visita el subárbol derecho. En el ejemplo de la figura 1 las visitas serían en este orden: b,d,a,e,c,f.

void inorden(tarbol *a)

{

  if (a != NULL) {

    inorden(a->izq);

    visitar(a);

    inorden(a->der);

  }

}

* Recorrido en postorden: se visitan primero el subárbol izquierdo, después el subárbol derecho, y por último el nodo actual. En el ejemplo de la figura 1 el recorrido quedaría así: d,b,e,f,c,a.

Motores de busqueda.....

¿Cómo funciona un motor de búsqueda?

Básicamente, los motores de búsqueda (search engines, SE) son bases de datos gigantescas que contienen información sobre el contenido de los sitios web que integran la web.

¿Cómo funciona el motor de búsqueda de google?

El motor de búsqueda más popular, Google, contiene más de 3.000.000.000 sitios web. Cuando introduces una frase o palabra, el motor buscará en su base de datos y devolverá resultados en un orden que estará determinado por su propio algoritmo.

Así pues, ¿cómo consiguen al principio toda esa información?

Los motores de búsqueda emplean el uso de arañas para recopilar la información de los sitios web. Las arañas rastrean los sitios web recopilando datos y siguen los enlaces que hay en las páginas. Las arañas rastrean Internet casi continuamente, recolectando las páginas nuevas y actualizadas de la Web para mantener sus resultados al día.

Programa # 7 -- Promedio mayor de 5 alumnos

#include"conio.h"
#include"stdio.h"
#include"iostream.h"
void buscar(char nom[27][5],int cal[5][3],float prom[5])
{
int cont=0,res=0;
float promf;
promf=prom[0];
while (cont<5)
{
if(promf>prom[cont])
{
promf=promf;
}
else
{
res=cont;
promf=prom[cont];
}
cont=cont+1;
}
printf("////////////////////////////////////////////////////////////////////////////////\nEl alumno %s con las siguientes calificaciones:\n*******************************************************************************\nCalificacion 1   ||   Calificacion 2   ||   Calificacion 3\n     %d                     %d                     %d \n\nCon un Promedio de: %.4f\n////////////////////////////////////////////////////////////////////////////////\n\n                    Creado por Francisco Aldana Hernandez ",nom[res],cal[res][0],cal[res][1],cal[res][2],promf);
}


void main()
{
int c=0,c2=0,calificacion[5][3];
char nombre[27][5];
float promedio[5];
while(c<5)
{
printf("             Sistema de Calificaciones con funciones\n----------------------------------------------------------------------------------------------------------------------------------------------------------------\n");
printf("Introduce el nombre\n");
scanf("%s",&nombre[c]);
while(c2<3)
{
printf("Introduce la calificacion\n");
scanf("%d",&calificacion[c][c2]);
promedio[c]+=calificacion[c][c2];
c2+=1;
}
promedio[c]=(promedio[c])/3;
clrscr();
c2-=3;
c+=1;
}
clrscr();
printf("               UPT System of ratings\n----------------------------------------------------------------------------------------------------------------------------------------------------------------\nEl alumno mas destacado es el siguiente:\n\n");
buscar(nombre,calificacion,promedio);
getch();
clrscr();
}

Programa # 6 -- Calificaciones mayores a 8

#include"conio.h"
#include"stdio.h"
void buscar(char nom[27][5],int cal[5])
{
int cont=0;
while (cont<5)
{
if(cal[cont]>=8)
{
printf("El alumno %s tiene la calificacion de %d\n",nom[cont],cal[cont]);
}
cont=cont+1;
}
}
void main()
{
int c=0,calificacion[5];
char nombre[27][5];
while(c<5)
{
printf("Introduce el nombre\n");
scanf("%s",&nombre[c]);
printf("Introduce la calificacion\n");
scanf("%d",&calificacion[c]);
clrscr();
c=c+1;
}
clrscr();
printf("Los siguientes alumnos tienen calificacion mayor o igual a 8\n\n");
buscar(nombre,calificacion);
getch();
clrscr();
}

Programa # 5 -- Torres de Hanoi

#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("\nIntroduce el numero 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);
    }
}

Programa # 4 -- Inversa de una cadena de caracteres

#include "stdio.h"
#include "conio.h"

void inversa(char s[])
{
if(s[0] == '\0')
return;
else
{
inversa(&s[1]);
putchar(s[0]);
}
}
void main()
{
char palabra[40];
clrscr();
printf("Escribe una palabra para invertir:\n");
gets(palabra);
clrscr();
printf("\nLa palabra inversa es: ");
inversa(palabra);
getch();
}

Programa # 3 -- Serie Fibonacci

#include<iostream.h>
#include<conio.h>
#include<stdio.h>
int funcion (int n)
{
clrscr();
    if (n==0) return 1;
    if (n==1) return 1;
    else
    return (funcion(n-1))+funcion(n-2);

}

int main()
{
    int x,fun,con=1;
    clrscr();
    cout<<"Ingrese un numero para calcular la serie fibonacci "<<endl;
    cin>>x;
    fun = funcion (x);
    clrscr();
    cout<<"La serie fibonacci de "<<x<<" es "<<fun<<" obtenidos de la suma de: "<<endl;
    getch();
    while(con<=x+1)
    {
    printf("%d",funcion(x-con));
    con=con+1;
    getch();
    }
    clrscr();
    return 0;
}

Programa # 2 -- Factorial de un número

#include<iostream.h>
#include<conio.h>
double factorial (int n)
{
clrscr();
    if (n<0) return 0;
    if (n==0) return 1;
    else if (n==1) return 1;
    else return n*factorial (n-1);
}

int main()
{
    double
     x,fac;
    cout<<"Ingrese un numero para calcular el factorial "<<endl;
    cin>>x;
    fac = factorial (x);
    cout<<"El factorial de: "<<x<<" = "<<fac<<endl;
    getch();
    return 0;
}

Programa # 1 -- Calculadora Basica

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

int suma ()
{
int a,b,res1;
printf("Introduce el valor de a:\n");
scanf("%d",&a);
printf("Introduce el valor de b:\n");
scanf("%d",&b);
res1=a+b;
return(res1);
}
int resta (int res2)
{
int d,e;
printf("Introduce el valor de a:\n");
scanf("%d",&d);
printf("Introduce el valor de b:\n");
scanf("%d",&e);
res2=d-e;
return(res2);
}
int divicion (int res3)
{
int g,h;
printf("Introduce el valor de a:\n");
scanf("%d",&g);
printf("Introduce el valor de b:\n");
scanf("%d",&h);
res3=g/h;
return(res3);
}
int multiplicacion (int res4)
{
int j,k;
printf("Introduce el valor de a:\n");
scanf("%d",&j);
printf("Introduce el valor de b:\n");
scanf("%d",&k);
res4=j*k;
return(res4);
}
void main()
{
int resultado;
int respuesta;
printf("Que operacion es la que deseas realizar?\n");
printf("\n\n\n1.-Suma\n");
printf("2.-Resta\n");
printf("3.-Divicion\n");
printf("4.-Multiplicacion\n********************************************\n");
scanf("%d",&respuesta);
switch(respuesta)
{
case 1:
cout<<"El resultado es "<<suma()<<endl;
break;
case 2:
cout<<"El resultado es "<<resta(resultado)<<endl;
getch();
break;
case 3:
cout<<"El resultado es "<<divicion(resultado)<<endl;
getch();
break;
case 4:
cout<<"El resultado es "<<multiplicacion(resultado)<<endl;
getch();
break;
}
getch();
}

Tipo de datos:

Ejemplo de Recursividad --- Serie Fibonacci

#include <stdio.h>
#include <conio.h>
/* definicion de la funcion recursiva fibonacci */
long fibonacci( long n )
{
    /* caso base */
    if ( n == 0 || n == 1 ) {
        return n;   }
    else { /* paso recursivo */
        return fibonacci( n - 1 ) + fibonacci( n - 2 );
    }
}
int main()
{
    long resultado; /* valor fibonacci */
    long numero;    /* numero a introducir por el usuario */
    printf("                Serie Fibonacci\n********************************************************************************\n\nIntroduzca un entero: " );
    scanf( "%ld", &numero);
    clrscr();
    resultado = fibonacci( numero );
    printf( "********************************************************************************\nEl Numero Fibonacci de ( %ld ) es --> = %ld\n", numero, resultado );
    getch();
        return 0;
        clrscr();
        /*La recursividad consume muchos recursos de
        memoria y tiempo de ejecución, y se debe aplicar
         a funciones que realmente le saquen partido.*/
}

Recursividad

Se utiliza para realizar una llamada a una función desde la misma función. Como ejemplo útil se puede presentar el cálculo de números factoriales. La recursividad y la iteración (ejecución en bucle) están muy relacionadas, cualquier acción que pueda realizarse con la recursividad puede realizarse con iteración y viceversa. Normalmente, un cálculo determinado se prestará a una técnica u otra, sólo necesita elegir el enfoque más natural o con el que se sienta más cómodo. Claramente, esta técnica puede constituir un modo de meterse en problemas. Es fácil crear una función recursiva que no llegue a devolver nunca un resultado definitivo y no pueda llegar a un punto de finalización. Este tipo de recursividad hace que el sistema ejecute lo que se conoce como bucle "infinito".

Para entender mejor lo que en realidad es el concepto de recursión veamos un poco lo referente a la secuencia de Fibonacci.

Ventajas:

1.- Proporciona simplicidad en la comprencion de los problemas.

2.- Es un metodo natural de resolver problemas.

3.- Permite un gran potencial de cálculo.

4.- La corrección de los algoritmos se comprueba facilmente.

Desventajas:

1.- Aumenta el consumo de recursos de la máquina (sobre todo de la pila) .

2.- Es más lenta que las interativas equivalentes (siempre que exista la solución iterativa equivalente).