sábado, 31 de agosto de 2013

2013/2-PA-2013.08.30: TAD Árvore em Java (PARCIAL)

TAD Árvore em Java

Classe Nó

public class No{
  int chave;
  No esquerda, direita;
  
  public No(int chave){ // construtor
    this.chave = chave;
this.direita = null;
this.esquerda = null;
  }
  // No no = new No(10);
}

Classe ArvoreBinaria

public class ArvoreBinaria{
  No raiz;  
  // método main - principal
  public static void main(String args[]){  
  }

  // pesquisa
// descricao textual
  No pesquisar(No no, int chave){
    if (no != null) {// 1) Se o nó for valido (existente)
      if (no.chave == chave){// 1.1) Se a chave for igual a chave do no
        return no;// 1.1.1) retornar a chave (achei!)
      } // 1.2) caso contrario:
 else if (chave < no.chave){// 1.2.1) Se a chave for menor que a chave do nó
        return pesquisar(no.esquerda, chave);// 1.2.1.1) navegar para a esquerda do nó
      } else if (chave > no.chave){// 1.2.2) Senão se a chave for maior que a chave do no
        return pesquisar(no.direita, chave);// 1.2.2.1) navegar para a direita do nó
      }// 1.2.3) voltar ao passo 1
    } else {// 2) Senão (no invalido)
// 2.1) informar que a chave nao existe  
 return null;
}
  }  
  // insercao
  No inserir (No no, int chave){
if (no == null){// 1) se o no for nulo
 no = new No(chave);// 1.1) criar o novo no
 return no;// 1.2) retornar o novo no criado
}else// 2) Senão
 if(chave < no.chave){// 2.1) Se a chave for menor que a chave do no
   return inserir(no.esquerda, chave);// 2.1.1.) inserir pela esquerda
 } else 
 if (chave > no.chave){// 2.3) Senão se a chave for maior que a chave do nó
   return inserir(no.direita, chave);// 2.3.1) inserir pela direita
   return null;// 2.4.1) A chave jah existe
 } else {// 2.4) Senão
 }
  }
  
  // caminhamentos
  
  a.raiz = new No(10);
}

2013/2-PA-2013.08.31: TAD Árvore em C

TAD Árvore

Arquivo cabeçalho (tad-arvore.h)

//tad arvore

// definicao da TAD
typedef char TipoChave;
// apontador para o nó da árvore
typedef struct TipoNo * TipoApontador;
// registro para o no
struct TipoNo{
  TipoChave chave;
  TipoApontador dir, esq;       
};

typedef struct TipoNo TipoNo;

// cabecalho para as funcoes
void inicializar(TipoApontador * a);

TipoChave pesquisar(TipoApontador a, TipoChave c);

void inserir(TipoApontador *a, TipoChave c);

void preOrdem(TipoApontador a);

void central(TipoApontador a);

void posOrdem(TipoApontador a);

// definicao das funcoes

void inicializar(TipoApontador * a){
  (*a) = NULL;
}

TipoChave pesquisar(TipoApontador a, TipoChave c){
// descricao textual
  if (a != NULL){// 1) Se o nó for valido (existente)
    if (c == a->chave){// 1.1) Se a chave for igual a chave do no
      return c;// 1.1.1) retornar a chave (achei!)
    } else// 1.2) caso contrario:
    if (c < a->chave){// 1.2.1) Se a chave for menor que a chave do nó
      return pesquisar(a->esq, c);// 1.2.1.1) navegar para a esquerda do nó
    } else if (c > a->chave){// 1.2.2) Senão se a chave for maior que a chave do no
      return pesquisar(a->dir, c);// 1.2.2.1) navegar para a direita do nó
    }// 1.2.3) voltar ao passo 1
  } else {// 2) Senão (no invalido)
    printf("INFO: no nao existe.\n");
    return -1;// 2.1) informar que a chave nao existe    
  }
}

void inserir(TipoApontador * a, TipoChave c){
// descricao textual
  if ((*a) == NULL){// 1) se nao houver no (i.e., no nulo)
    (*a) = (TipoApontador) malloc(sizeof(TipoNo));// 1.1) criar um novo no
    (*a)->chave = c;// 1.2) colocar a chave no novo no
    (*a)->dir = NULL;
    (*a)->esq = NULL;
  }else if (c < (*a)->chave){// 2) se a chave for menor que a chave no no
    inserir(&(*a)->esq, c);// 2.1) navegar para a esquerda do no// 2.2) voltar ao passo 1
  }else if (c > (*a)->chave){ // 3) se a chave for maior que a chave no no
    inserir(&(*a)->dir, c);// 3.1) navegar para a direita do no  }// 3.2) voltar ao passo 1
  } else {// 4) senao (chave for igual)
    printf("INFO: Chave jah existe!\n");// 4.1) a chave jah existe     
  }
}

void central(TipoApontador a){
  if (a == NULL){
    return;
  }
  central(a->esq);
  printf("[%c]  ", a->chave);
  central(a->dir);
}

void preOrdem(TipoApontador a){
  if (a == NULL){
    return;
  }
  printf("[%c]  ", a->chave);
  preOrdem(a->esq);
  preOrdem(a->dir);
}

void posOrdem(TipoApontador a){
  if (a == NULL){
    return;
  }
  posOrdem(a->esq);
  posOrdem(a->dir);
  printf("[%c]  ", a->chave);
}

Arquivo principal (main.c)

#include <stdio.h>
#include <stdlib.h>
#include "tad-arvore.h"

int main(int argc, char *argv[])
{
  TipoApontador a;
  TipoChave c;

  printf("Inicializacao da arvore:\n");
  inicializar(&a); // inicializar a arvore
  
  printf("Conteudo da arvore (CENTRAL):\n");
  central(a); printf("\n");
  
  int chaves[] = {'t', 'h', 'e', 'b', 'o', 'o', 'k'}, j;
  for (j = 0; j < 7; j++){
     c = chaves[j];
     inserir(&a, c);
     printf("Conteudo da arvore (CENTRAL):\n");
     central(a);  
     printf("\n");
  }
  printf("Conteudo da arvore (PRE-ORDEM):\n");
  preOrdem(a);  printf("\n");
  printf("Conteudo da arvore (POS-ORDEM):\n");
  posOrdem(a);  printf("\n");
  printf("Pesquisando por 'b':%c\n", pesquisar(a, 'b'));
  printf("Pesquisando por 'x':%c\n", pesquisar(a, 'x'));
  system("PAUSE");
  return 0;
}

sexta-feira, 30 de agosto de 2013

2013/2-PA-TAD árvore - classe No.java

public class No{
  int chave;
  No esquerda, direita;
 
  public No(int chave){ // construtor
    this.chave = chave;
    this.direita = null;
    this.esquerda = null;
  }
  // No no = new No(10);
}

2013/2-PA-2013.08.30: TAD árvore em Java: notas aula

public class ArvoreBinaria{
  No raiz; 
  // método main - principal
  public static void main(String args[]){ 
  }

  // pesquisa
// descricao textual
  No pesquisar(No no, int chave){
    if (no != null) {// 1) Se o nó for valido (existente)
      if (no.chave == chave){// 1.1) Se a chave for igual a chave do no
        return no;// 1.1.1) retornar a chave (achei!)
      } // 1.2) caso contrario:
      else if (chave < no.chave){// 1.2.1) Se a chave for menor que a chave do nó
        return pesquisar(no.esquerda, chave);// 1.2.1.1) navegar para a esquerda do nó
      } else if (chave > no.chave){// 1.2.2) Senão se a chave for maior que a chave do no
        return pesquisar(no.direita, chave);// 1.2.2.1) navegar para a direita do nó
      }// 1.2.3) voltar ao passo 1
    } else {// 2) Senão (no invalido)
// 2.1) informar que a chave nao existe 
      return null;
    }
  } 
  // insercao
  No inserir (No no, int chave){
    if (no == null){// 1) se o no for nulo
      no = new No(chave);// 1.1) criar o novo no
      return no;// 1.2) retornar o novo no criado
    }else// 2) Senão
      if(chave < no.chave){// 2.1) Se a chave for menor que a chave do no
        return inserir(no.esquerda, chave);// 2.1.1.) inserir pela esquerda
      } else
      if (chave > no.chave){// 2.3) Senão se a chave for maior que a chave do nó
        return inserir(no.direita, chave);// 2.3.1) inserir pela direita
        return null;// 2.4.1) A chave jah existe
      } else {// 2.4) Senão
      }
  }
 
  // caminhamentos
}

2013/2-AED-2013.08.29: TAD Vetor com função MAIN

// TAD Vetor 

// definição de tipos de dados (typedef e struct)
typedef int TipoChave;
struct T_Vetor{
  int tamanho;
  int capacidade;
  TipoChave a[100];
};

typedef struct T_Vetor TipoVetor;

// definição de operações (cabeçalho)

// criar o vetor
void criarVetor(TipoVetor *v, int capacidade);

// insere um elemento no vetor
int inserirEmVetor(TipoVetor *v, TipoChave a);

// obter tamanho
int obterTamanho(TipoVetor v);

int obterPosicaoDe(TipoVetor v, TipoChave chave);

int obterElementoEm(TipoVetor v, int pos);

void imprimirVetor(TipoVetor v);

int estahCheio(TipoVetor v);

void retirarElementoEm(TipoVetor *v, int pos);

// implementação das operações (funções)

void criarVetor(TipoVetor *v, int capacidade){
  if (capacidade < 1) {
    printf("ERRO: Capacidade deve ser maior que zero");
return;
  }
  v->capacidade = capacidade;
  v->tamanho = 0;  
}

int inserirEmVetor(TipoVetor *v, TipoChave a){
  if (estahCheio(*v)){
    printf("ERRO: Vetor estah cheio!!") 
return -1;
  }
  int pos = v->tamanho;
  v->a[pos] = a;
  v->tamanho++;
  return pos;
}

int obterTamanho(TipoVetor v){
  return v.tamanho;
}

int obterPosicaoDe(TipoVetor v, TipoChave chave){
  int c;
  for (c = 0; c < v.tamanho; c++){
    if (v.a[c] == chave){
 return c;
}
  }
  return -1;
}

int obterElementoEm(TipoVetor v, int pos){
  if (pos >= v.tamanho){
    printf("ERRO: posição vazia ou inexistente");
return -1;
  }
  return v.a[pos];
}

void imprimirVetor(TipoVetor v){
  int c;
  printf("Tamanho: %d\n", v.tamanho);
  printf("Capacidade: %d\n", v.capacidade);
  for (c = 0; c < v.tamanho; c++){
    printf("%d ", v.a[c]);
  }
  printf("\n");  
}

int estahCheio(TipoVetor v){
  // se for negativo, nao estah cheio
  // se for zero, estah cheio
  return v.tamanho - v.capacidade;
}

void retirarElementoEm(TipoVetor *v, int pos){


}


int main(){
  TipoVetor v;
  TipoChave c;
  
  //void criarVetor(TipoVetor *v, int capacidade){
  criarVetor(&v, 10);
  
  imprimirVetor(v);
  
  //int inserirEmVetor(TipoVetor *v, TipoChave a){
  c = 12;
  inserirEmVetor(&v, c);
  
  c = 10;
  inserirEmVetor(&v, c);
  
  //int obterPosicaoDe(TipoVetor v, TipoChave chave){
  c = 12;
  int pos = obterPosicaoDe(v, c);
  
  //int obterElementoEm(TipoVetor v, int pos){
  c = obterElementoEm(v, 0);
  
  imprimirVetor(v);
  // capacidade: 10
  // tamanho   :  2
  // Valores   : [ 12, 10]
}









2013/2-AED-2013.08.29: TAD Matriz


// tad matriz

// definição da TAD
typedef int TipoChave;

struct t_matriz{
  int capacidade;
  int tamanho;
  int linha;
  int coluna;
  int numLinhas;
  int numColunas;
  TipoChave **a;
};

typedef struct t_matriz TipoMatriz;

// operações da TAD matriz

// criar uma nova matriz
void criarMatriz(TipoMatriz *m, int numLinhas, int numColunas);

void imprimirMatriz(TipoMatriz m);

void inserirMatriz(TipoMatriz *m, TipoChave c);

TipoChave obterElementoEm(TipoMatriz m, int linha, int coluna);

void obterPosicaoDe(TipoMatriz m, TipoChave c, 
    int *linha, int *coluna);
int cheiaMatriz(TipoMatriz m);

// implementacao

void criarMatriz(TipoMatriz *m, int numLinhas, int numColunas){
  int c = 0;
  m->numLinhas = numLinhas;
  m->numColunas = numColunas;
  m->capacidade = numLinhas * numColunas;
  m->tamanho = 0;
  m->linha = 0;
  m->coluna = 0;
  
  m->a = (int **) malloc(numLinhas * sizeof(int *));
  for (c = 0; c < numLinhas; c++){
    m->a[c] = (int *) malloc (numColunas * sizeof (int));
  }
  
}

void imprimirMatriz(TipoMatriz m){
  printf("Tamanho: %d\n", m.tamanho);
  printf("Capacidade: %d\n", m.capacidade);
  printf("Dimensao: %dx%d\n", m.numLinhas, m.numColunas);
  int i, j;
  for (i = 0; i < m.numLinhas; i++){
    for (j = 0; j < m.numColunas; j++){
 printf("%d ", m.a[i][j]);
}
  }
}