Athanazio

contando ninguém acredita que os figuras passaram o domingo internados no café da praça de alimentação do shopping nova américa … que coisa !! mas o pior de tudo é que os caras gostam disto, nerd eh fogo, curte este negócio de exercício mental mesmo.

mais uma saraivada de exercícios, e listas disto, algoritmos daquilo, e no fim das contas, está no fazendo bem, o cérebro esta sendo moldado para ser parecer com uma bisnaga, se é que é a forma correta

vimos de tudo neste domingo, desde uma moça que comprou uma calça menor que suas formas, que resultou num cofre bem em frente dos nobre heróis, que combatiam as listas encadeadas teimosas e as regiões formadas por retas segmentos e seus filhotes, e também divertidas moças de avental amarelo que cismavam em somar cada centavo consumido para ver se dava os benditos R$25 para nos dar direito ao uso da tomada …

estes são os registros fotográficos do que vimos neste dia tão cansativo mas que deu um caldo de primeira ! aliás a canja estava ótima hehehe.

Além das imagens retumbantes também gravei um video chatinho explicando um algoritmo que resolvemos implementar em C, porque como eu sou esperto, não tinha baixado a documentação do Lua para o computador e como eu não me lembro de cabeça como fazer ponteiros em Lua, na verdade nem sei se dá fizemos em C mesmo.

abaixo segue o video e o código fonte.

inversão de lista encadeada from Hamilton Lima on Vimeo.

invert.c

/*
 * inverte lista encadeada sem vetor auxiliar
 * 2009-05-10 athanazio / fabio corato
 * 2009-05-11 athanazio -- correcao para imprimir todos da lista
 *
 * vespera de prova -- socorroooooo -- ateh agora no nova america ...
 * alguem tem uma moeda ae ? (domingo dia das maes)
 */

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>

struct node {
    int val;
    struct node* prox;
};

struct node* L;

struct node* criaUm(){
    struct node *novo;
    novo = malloc(sizeof (struct node));
    novo->val = rand() % 100;
    novo->prox = NULL;
    printf( "%d\n", novo->val);
    return novo;
}

void preencheComDados(){

    L = malloc(sizeof (struct node*));
    struct node* atual = L;

    int n;
    for(n=0; n < 5; n++){
        atual->prox = criaUm();
        atual = atual->prox;
    }
}

void inverte(){

    struct node* atual = L->prox;
    struct node* proximo = L->prox;

    /*
     * preserva o link do proximo elemento na sequencia
     * a->b->c
     * temp = c, porque vamos mudar o prox de b para a (a<-b)
     * e precisamos saber como caminhar com o atual na lista encadeada
     */
    struct node* temp = L->prox;

    while( proximo != NULL ){
        // preserva ponteiro para caminhar no encadeamento
        temp = temp->prox;

        // inverte o caminho do elemento posterior ao atual
        proximo->prox = atual;

        // determina o proximo elemento a ser processado
        atual = proximo;

        // determina o elemento posterior
        proximo = temp;
    }

    // remove link do primeiro elemento com o segundo elemento
    L->prox->prox = NULL;

    // aponta para a nova cabeca da lista
    L->prox = atual;
}

void print(){
    struct node *atual = L->prox;

    while(atual != NULL ){
        printf( "%d ", atual->val );
        atual = atual->prox;
    }
}

int main() {
    srand(time(NULL));
    preencheComDados();

    printf("original\n");
    print();

    inverte();

    printf("\ninvertida \n");
    print();

    printf( "\n");
}

This entry was posted on Sunday, May 10th, 2009 at 11:32 pm and is filed under trecos. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.