METODOS DE ORDENAMIENTO

CODIGO FIBONACCI

1. #include <iostream.h>
2. #include <stdlib.h>
3.  
4. void main()
5. {
6.   int a,b,x,c,l;
7.   a=1; b=1; x=0; c=0;
8.   cout<<"Introduce el limite de la serie: "; cin>>l;
9.   if (l>0) {
10.     if (l==1) cout<<"1"<<endl;
11.     else
12.       {
13.       cout<<endl<<a<<", "<<b<<", ";
14.       while (c<l-2)
15.         {
16.          c++;
17.          x=a+b;
18.          cout<<x<<", ";
19.          a=b;
20.          b=x;
21.         }
22.       }
23.   }
24.   system("PAUSE");
25. }

EXPOSICION EN EQUIPO

LISTAS ENLAZADAS DOBLEMENTE CIRCULARES

#include<stdio.h>/* for printf*/
#include <stdl ib.h>/* 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;

PANTALLA -LISTAS ENLAZADAS-

EJEMPLO DE LISTAS ENLAZADAS

#include <stdio.h>   /* for printf */
#include <stdlib.h>  /* for malloc */

typedef struct ns {
        int data;
        struct ns *next;
} node;

node *list_add(node **p, int i) {
    /* algunos compiladores no requieren un casting del valor del retorno para malloc  */
    node *n = (node *)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_search(node **n, int i) {
    while (*n != NULL) {
        if ((*n)->data == i) {
            return n;
        }
        n = &(*n)->next;
    }
    return NULL;
}

void list_print(node *n) {
    if (n == NULL) {
        printf("lista esta vacía\n");
    }
    while (n != NULL) {
        printf("print %p %p %d\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: 1 0 */
    list_add(&n, 2); /* lista: 2 1 0 */
    list_add(&n, 3); /* lista: 3 2 1 0 */
    list_add(&n, 4); /* lista: 4 3 2 1 0 */
    list_print(n);
    list_remove(&n);            /* borrar primero(4) */
    list_remove(&n->next);      /* borrar nuevo segundo (2) */
    list_remove(list_search(&n, 1)); /* eliminar la celda que contiene el 1 (primera) */
    list_remove(&n->next);      /* eliminar segundo nodo del final(0)*/
    list_remove(&n);            /* eliminar ultimo nodo (3) */
    list_print(n);

    return 0;

VENTANA2