SEGUNDO PARCIAL

CONCEPTO DE RECURSIVIDAD

La recursividad es una técnica de programación importante. 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. Él factorial de 0 es, por definición, 1. Los factoriales de números mayores se calculan mediante la multiplicación de 1 * 2 * ..., incrementando el número de 1 en 1 hasta llegar al número para el que se está calculando el factorial.

CONCEPTO DE ÁRBOL:

Es una estructura de datos ampliamente usada que imita la forma de un árbol (un conjunto de nodos conectados). Un nodo es la unidad sobre la que se construye el árbol y puede tener cero o más nodos hijos conectados a él. Se dice que un nodo a es padre de un nodo b si existe un enlace desde a hasta b (en ese caso, también decimos que b es hijo de a). Sólo puede haber un único nodo sin padres, que llamaremos raíz. Un nodo que no tiene hijos se conoce como hoja. Los demás nodos (tienen padre y uno o varios hijos) se les conoce como rama.

FOTOS DE EXPOSICIÓN:

PRACTICA DE LISITA ENLAZADAS DOBLEMENTE CIRCULARES

#include/* for printf*/

#include /* formalloc*/

typedef struct ns {

        void*data; 

        struct ns *next;

        } node;

        node*list_add(node**p,int i){

                                  /*algunos compiladores no requieren de un casting del valor del retorno para mal loc*/
                               node*n=(node*)for malloc(sizeof(node));
                                  if (n==NULL);
                                  return NULL;
                                  n ->next =*p;
                                  *p=n;
                                  n->data=i;
                                  return n;
                                  }
                                  void list_remove(node**p){ /*borrar cabeza*/
                                  if (*p!=NULL){
                                                node*n=*p;
                                                *p=(*p)->next;
                                                free (n);
                                                {
                                                 }
                                                 node**list_sarch (node**n,int i){
                                                                  while (*n!=NULL){
                                                                        return n;
                                                                        {
                                                                               n=&(*n)->next;
                                                                               }
                                                                               return NUL;
                                                                               }
                                                                               void list_printf(node*n){
                                                                                    if (n==NULL){
                                                                                                 printf("lista vacia =n");
                                                                                                 {
                                                                                                               while (n!=NULL);{
                                                                                                                     prinft("print %p%Pd=n",n,n->next,n->data);
                                                                                                                     n=n->next;
                                                                                                                     }
                                                                                                                     }
                                                                                                                     int main (void){
                                                                                                                         node*n=NULL;
                                                                                                                         list_add(&n,0);/*lista:0*/
                                                                                                                         list_add(&n,1);/*lista:10*/
                                                                                                                         list_add(&n,2);/*lista:210*/
                                                                                                                         list_add(&n,3);/*lista:3210*/
                                                                                                                         list_add(&n,4);/*lista:43210*/
                                                                                                                         list_prinft(n);
                                                                                                                         list_prinft(&n);
                                                                                                                         list_renove(&n); /*borrar primero(4)*/
                                                                                                                         list_renove(&n->next);/*borrar nuevo(2)*/
                                                                                                                         list_renove(list_search(&n,1));/*eliminar celda que contiene el 1(primera)*/
                                                                                                                         list_renove(&n->next); /*eliminar segundo nodo del final(0)*/
                                                                                                                         list_print(n);/*eliminar ultimonodo(3)*/
                                                                                                                         return 0;

PRACTICA DE FIBONACCI

#include
/***************************************************************************
* Ejemplo: Calculo iterativo del n-esimo termino de fibonacci
* Por definicion:
* Fibonacci(0) = 0
* Fibonacci(1) = 1
* Fibonacci(n) = Fibonacci(n - 1) + Fibonacci(n - 2)
***************************************************************************/
/***************************************************************************
* Funcion que calcula iterativamente el n-esimo termino de fibonacci
***************************************************************************/
double Fibonacci(int n) {
int i;
double Fibi, Fibn1, Fibn2;
switch (n) {
case 0 : return 0;
case 1 : return 1;
default :
Fibn2 = 0; /* Fibonacci(n - 2) */
Fibn1 = 1; /* Fibonacci(n - 1) */
for (i = 2; i <= n; i++) { Fibi = Fibn1 + Fibn2; Fibn2 = Fibn1; Fibn1 = Fibi; } return Fibi; } } /*************************************************************************** * Programa que calcula, de forma iterativa, el termino n-esimo de la * sucesion de fibonacci, para un valor n dado por el usuario. ***************************************************************************/ int main() { int n; /* Se solicita al usuario el valor de n */ printf("Ingrese el valor de n: "); scanf("%d", &n); /* scanf requiere puntero: & */ /* Imprime el fibonacci de n */ printf("El termino %d de Fibonacci es: %.0lf\n", n, Fibonacci(n)); }

PRACTICA "SUICIDA"

#include

int main()

{

int k;

int n;

int gente[100];

int die=0, cont=0;

int wisin;

printf("Introduzca el numero de personas:");

scanf("%d",&n);

printf("\nIntroduce el intervalo en que mataras: ");

scanf("%d",&k);

for(int c=0; c

gente[c] = (c+1);

}

printf("\n\n Las personas murieron el el orden siguiente:\n");

while(die != (n-1)) {

for(int c1=0; c1

if(gente[c1]!= 0) {

cont += 1;

if(cont ==k ){

cont = 0;

printf("%d\t",gente[c1]);

gente[c1] = 0;

die += 1;

}

}

}

}

for(int c2=0; c2 if(gente[c2] != 0) {

wisin = gente[c2];

}

}

printf("\n\nEl sobreviviente es el numero: %d\n\n", wisin);

system("pause");

return 0;

getch();

}