novos arquivos adicionados!!

fonte/U0 - Nivelamento/java/argumentoMain/ArgumentoMain.java

@@ -0,0 +1,6 @@
+class ArgumentoMain {
+   public static void main (String[] args){
+      System.out.println("Primeiro parametro: " + args[0]);
+      System.out.println("Numero de parametros: " + args.length);
+   }
+}

fonte/U0 - Nivelamento/java/arquivo/ExemploArq01Escrita.java

@@ -0,0 +1,21 @@
+class ExemploArq01Escrita
+{
+  public static void main(String[] args)
+  {
+     //Abrir o arquivo texto
+     Arq.openWrite("exemplo.txt");
+
+
+     //Escrever no arquivo texto
+     Arq.println(1);
+     Arq.println(5.3);
+     Arq.println('X');
+     Arq.println(true);
+     Arq.println("Algoritmos");
+
+
+     //Fechar o arquivo texto
+     Arq.close();
+
+  } // Fim main()
+} // Fim class

fonte/U0 - Nivelamento/java/arquivo/ExemploArq02Leitura.java

@@ -0,0 +1,28 @@
+class ExemploArq02Leitura
+{
+  public static void main(String[] args)
+  {
+     //Abrir o arquivo texto
+     Arq.openRead("exemplo.txt");
+
+
+     //Ler o arquivo texto
+     int inteiro = Arq.readInt();
+     double real = Arq.readDouble();
+     char caractere = Arq.readChar();
+     boolean boleano = Arq.readBoolean();
+     String str = Arq.readString();
+
+
+     //Fechar o arquivo texto
+     Arq.close();
+
+     //Mostrar os valores lidos na tela
+     MyIO.println("inteiro: " + inteiro);
+     MyIO.println("real: " + real);
+     MyIO.println("caractere: " + caractere);
+     MyIO.println("boleano: " + boleano);
+     MyIO.println("str: " + str);
+
+  } // Fim main()
+} // Fim class

fonte/U0 - Nivelamento/java/arquivo/ExemploArq02bLeitura.java

@@ -0,0 +1,28 @@
+class ExemploArq02bLeitura
+{
+  public static void main(String[] args)
+  {
+     //Abrir o arquivo texto
+     Arq.openRead("exemplo.txt");
+
+
+     //Ler o arquivo texto
+     int inteiro = Integer.parseInt(Arq.readLine());
+     double real = Double.parseDouble(Arq.readLine().replace(",","."));
+     char caractere = Arq.readLine().charAt(0);
+     boolean boleano = Boolean.parseBoolean(Arq.readLine());
+     String str = Arq.readLine();
+
+
+     //Fechar o arquivo texto
+     Arq.close();
+
+     //Mostrar os valores lidos na tela
+     MyIO.println("inteiro: " + inteiro);
+     MyIO.println("real: " + real);
+     MyIO.println("caractere: " + caractere);
+     MyIO.println("boleano: " + boleano);
+     MyIO.println("str: " + str);
+
+  } // Fim main()
+} // Fim class

fonte/U0 - Nivelamento/java/arquivo/ExemploArq03Exercicio.java

@@ -0,0 +1,16 @@
+class ExemploArq03Exercicio {
+   public static void main (String[] args){
+      Arq.openRead("exemplo.txt");
+
+      String str  = "";
+      while (Arq.hasNext() == true){
+         str += Arq.readChar();
+      }
+
+      Arq.close();
+
+      Arq.openWrite("copia.txt");
+      Arq.print(str);
+      Arq.close();
+   }
+}

fonte/U0 - Nivelamento/java/arquivo/ExemploRAF01Escrita.java

@@ -0,0 +1,16 @@
+import java.io.*;  
+
+public class ExemploRAF01Escrita {  
+   public static void main(String args[]) throws Exception {
+
+      RandomAccessFile raf = new RandomAccessFile("exemplo.txt","rw");  
+
+      raf.writeInt(1);  
+      raf.writeDouble(5.3);  
+      raf.writeChar('X');  
+      raf.writeBoolean(true);  
+      raf.writeBytes("Algoritmos");          
+
+      raf.close();
+   }  
+}  

fonte/U0 - Nivelamento/java/arquivo/ExemploRAF02Leitura.java

@@ -0,0 +1,22 @@
+import java.io.*;
+
+class ExemploRAF02Leitura {
+   public static void main (String[] args) throws Exception{
+      RandomAccessFile raf = new RandomAccessFile("exemplo.txt", "rw");
+
+      int inteiro  = raf.readInt();
+      double real = raf.readDouble();
+      char caractere  = raf.readChar();
+      boolean boleano  = raf.readBoolean();
+      String str  = raf.readLine();
+
+      raf.close();
+
+      System.out.println("inteiro: " + inteiro);
+      System.out.println("real: " + real);
+      System.out.println("caractere: " + caractere);
+      System.out.println("boleano: " + boleano);
+      System.out.println("str: " + str);
+   }
+}
+

fonte/U0 - Nivelamento/java/arquivo/ExemploRAF03Cabecote.java

@@ -0,0 +1,29 @@
+import java.io.*;  
+
+public class ExemploRAF03Cabecote {  
+   public static void main(String args[]) throws Exception {
+
+      RandomAccessFile raf = new RandomAccessFile("exemplo.txt","rw");  
+
+      raf.writeInt(1);  
+      raf.writeDouble(5.3);  
+      raf.writeChar('X');  
+      raf.writeBoolean(true);  
+      raf.writeBytes("Algoritmos");
+
+      raf.seek(0); //Retornando o cabecote para a posicao 0
+      System.out.println(raf.readInt()); //imprimindo o inteiro
+
+      raf.seek(12); //Setando o cabecote na posicao 12 (do caractere,
+                    //12 = 4 do int + 8 do double)
+      System.out.println(raf.readChar());
+
+      raf.seek(12); //Setando o cabecote novamente na posicao 12
+      raf.writeChar('@'); //Substituindo o caractere
+
+      raf.seek(12);
+      System.out.println(raf.readChar());
+
+      raf.close();
+   }  
+}  

fonte/U0 - Nivelamento/java/classeObjeto/Principal.java

@@ -0,0 +1,44 @@
+/**
+ * Introducao a programacao orientada por objetos
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Principal
+{
+   public static void main(String[] args)
+   {
+      Retangulo r1 = new Retangulo();
+      Retangulo r2 = new Retangulo();
+
+      r1.lerTudo();
+      r1.escreverTudo();
+
+      r2.lerTudo();
+      r2.escreverTudo();
+
+      if (r1.comparar(r2.getB(), r2.getH()) == true){
+         System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao iguais!");
+      }else{
+         System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao diferentes!");
+      }
+
+      if (r1.comparar(r2) == true){
+         System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao iguais!");
+      }else{
+         System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao diferentes!");
+      }
+
+      if (r1.comparar(r1) == true){
+         System.out.println("Os retangulos " + r1.getNome() + " e " + r1.getNome() + "sao iguais!");
+      }else{
+         System.out.println("Os retangulos " + r1.getNome() + " e " + r1.getNome() + "sao diferentes!");
+      }
+
+      if (r2.comparar(r1) == true){
+         System.out.println("Os retangulos " + r2.getNome() + " e " + r1.getNome() + "sao iguais!");
+      }else{
+         System.out.println("Os retangulos " + r2.getNome() + " e " + r1.getNome() + "sao diferentes!");
+      }
+   }
+}
+

fonte/U0 - Nivelamento/java/classeObjeto/Retangulo.java

@@ -0,0 +1,102 @@
+/**
+ * Introducao a programacao orientada por objetos
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Retangulo{
+   //Declaracao de variaveis
+   private double b, h;
+   private String nome;
+
+   //Construtor vazio
+   public Retangulo(){
+      this.b = this.h = 0;
+      this.nome = "";
+   }
+
+   //Construtor que recebe parametros
+   public Retangulo(double b, double h, String nome){
+      this.b = b;
+      this.h = h;
+      this.nome = nome;
+   }
+
+   public double getB(){
+      return this.b;
+   }
+
+   public void setB(double b){
+      this.b = b;
+   }
+
+   public double getH(){
+      return this.h;
+   }
+
+   public void setH(double h){
+      this.h = h;
+   }
+
+   public String getNome(){
+      return this.nome;
+   }
+
+   public void setNome(String nome){
+      this.nome = nome;
+   }
+
+   public void lerTudo(){
+      b = MyIO.readDouble("Entre com a base: ");
+      h = MyIO.readDouble("Entre com a altura: ");
+      nome = MyIO.readString("Entre com o nome: ");
+   }
+
+   public void escreverTudo(){
+      System.out.println("NOME: " + nome);
+      System.out.println("Base: " + b);
+      System.out.println("Altura: " + h);
+      System.out.println("Area: " + getArea());
+      System.out.println("Diagonal: " + getDiagonal());
+      System.out.println("Perimetro: " + getPerimetro());
+   }
+
+
+   //Retornar a area
+   public double getArea(){
+      return (b * h);
+   }
+
+   //Retornar o perimetro
+   public double getPerimetro(){
+      return ((b + h) * 2);
+   }
+
+   //Retornar a diagonal
+   public double getDiagonal(){
+      return Math.sqrt(b * b + h * h);
+   }
+
+
+   //Comparar
+   public boolean comparar(double outraB, double outraH){
+      boolean resp;
+
+      if (this.b == outraB && this.h == outraH){
+         resp = true;
+      }else{
+         resp = false;
+      }
+
+      return resp;
+   }
+
+   //Comparar
+   //public boolean comparar(double outraB, double outraH){
+   //    return (this.b == outraB && this.h == outraH);
+   //}
+
+   //Comparar
+   public boolean comparar(Retangulo x){
+      return (this.b == x.b && this.h == x.h);
+   }
+}

fonte/U0 - Nivelamento/java/entradaSaida/ExemploBufferedReader.java

@@ -0,0 +1,43 @@
+import java.io.*;
+import java.nio.charset.*;
+
+class ExemploBufferedReader {
+
+   //Declaracao da classe BufferedReader
+   private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in, Charset.forName("ISO-8859-1")));
+
+   public static String readString(){
+      String s = "";
+      char tmp;
+      try{
+         do{
+            tmp = (char)in.read();
+            if(tmp != '\n' && tmp != ' ' && tmp != 13){
+               s += tmp;
+            }
+         }while(tmp != '\n' && tmp != ' ');
+      }catch(IOException ioe){}
+      return s;
+   }
+
+   public static void main(String [] args) throws Exception {
+
+      System.out.printf("Entre com uma palavra: ");
+      String str = readString();
+
+      System.out.printf("Entre com um numero inteiro: ");
+      int inteiro = Integer.parseInt(readString().trim());
+
+      System.out.printf("Entre com um numero real: ");
+      double real = Double.parseDouble(readString().trim().replace(",","."));
+
+      System.out.printf("Entre com um caractere: ");
+      char caractere = (char)in.read();
+
+      System.out.println("Sua str: " + str);
+      System.out.println("Seu inteiro: " + inteiro);
+      System.out.println("Seu real: " + real);
+      System.out.println("Seu caractere: " + caractere);
+    } // fim main ()
+} // fim class 
+

fonte/U0 - Nivelamento/java/entradaSaida/ExemploMyIO.java

@@ -0,0 +1,13 @@
+class ExemploMyIO {
+   public static void main (String[] args){
+      String str = MyIO.readString("Entre com uma palavra: ");
+      int inteiro = MyIO.readInt("Entre com um inteiro: ");
+      double real = MyIO.readDouble("Entre com um real: ");
+      char caractere = MyIO.readChar("Entre com um caractere: ");
+
+      MyIO.println("Sua string: " + str);
+      MyIO.println("Seu inteiro: " + inteiro);
+      MyIO.println("Seu real: " + real);
+      MyIO.println("Seu caractere: " + caractere);
+   }
+}

fonte/U0 - Nivelamento/java/entradaSaida/ExemploScanner.java

@@ -0,0 +1,28 @@
+import java.util.*;
+
+class ExemploScanner {
+   public static void main(String [] args){
+
+      //Declaracao da classe scanner
+      Scanner scanner = new Scanner (System.in);
+
+      System.out.printf("Entre com uma palavra: ");
+      String str = scanner.nextLine();
+
+      System.out.printf("Entre com um caractere: ");
+      char caractere = scanner.nextLine().charAt(0);
+
+      System.out.printf("Entre com um numero inteiro: ");
+      int inteiro = scanner.nextInt();
+
+      System.out.printf("Entre com um numero real: ");
+      double real = scanner.nextDouble();
+
+      System.out.println("Sua str: " + str);
+      System.out.println("Seu inteiro: " + inteiro);
+      System.out.println("Seu real: " + real);
+      System.out.println("Seu caractere: " + caractere);
+
+   } // fim main ()
+} // fim class 
+

fonte/U0 - Nivelamento/java/entradaSaida/entrada.txt

@@ -0,0 +1,5 @@
+hoje
+3000000
+12.3
+a
+

fonte/U0 - Nivelamento/java/ponteiro/Ponteiro01Array.java

@@ -0,0 +1,14 @@
+/**
+ * Ponteiro
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Ponteiro01Array {
+   public static void main (String[] args) {
+      int[] vet = new int [10];
+      System.out.println(vet);
+
+      vet = new int [10];
+      System.out.println(vet);
+   }
+}

fonte/U0 - Nivelamento/java/ponteiro/Ponteiro02PassagemTipoPrimitivo.java

@@ -0,0 +1,19 @@
+/**
+ * Ponteiro
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Ponteiro02PassagemTipoPrimitivo {
+   public static void passagemDeTipoPrimitivo(int a){
+      System.out.println("a: " + a);
+      a = 10;
+      System.out.println("a: " + a);
+   }
+   public static void main(String[] args) {
+      int x = 5;
+      System.out.println("x: " + x);
+      passagemDeTipoPrimitivo(x);
+      System.out.println("x: " + x);
+   }
+}
+

fonte/U0 - Nivelamento/java/ponteiro/Ponteiro03PassagemArray.java

@@ -0,0 +1,31 @@
+/**
+ * Ponteiro
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Ponteiro03PassagemArray { 
+   public static void passangemDeArray(int[] b){
+      for(int i = 0; i < 5; i++){
+         b[i] *= 5;
+         System.out.println("b[" + i + "]: " + b[i]);
+      }
+      b = new int[5];
+      for(int i = 0; i < 5; i++){
+         b[i] = i;
+         System.out.println("b[" + i + "]: " + b[i]);
+      }
+   }
+   public static void main(String[] args) {
+      int[] y = new int [5];
+
+      for(int i = 0; i < 5; i++){
+         y[i] = i;
+         System.out.println("y[" + i + "]: " + y[i]);
+      }
+      passangemDeArray(y);
+      for(int i = 0; i < 5; i++){
+         System.out.println("y[" + i + "]: " + y[i]);
+      }
+   }
+}
+

fonte/U0 - Nivelamento/java/ponteiro/Ponteiro04Objeto.java

@@ -0,0 +1,55 @@
+/**
+ * Ponteiro
+ * @author Max do Val Machado
+ * @version 3 01/2016
+ */
+class Cliente{
+   private int codigo;
+   private String nome;
+   public Cliente(){
+      this(0, "");
+   }
+   public Cliente(int codigo){
+      this(codigo, "");
+   }
+   public Cliente(int codigo, String nome){
+      this.codigo = codigo;
+      this.nome = nome;
+   }
+   public int getCodigo(){
+      return codigo;
+   }
+   public void setCodigo(int codigo){
+      this.codigo = codigo;
+   }
+   public String getNome(){
+      return nome;
+   }
+   public void setNome(String nome){
+      this.nome = nome;
+   }
+}
+
+class Ponteiro04Objeto {
+
+   public static void main (String[] args){
+
+      //Declarando tres ponteiros 
+      Cliente c1 = null, c2 = null, c3 = null;
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+
+      //Alocando areas de memoria (ou inicializando objetos) e apontando os ponteiros para tais areas
+      c1 = new Cliente(1, "aa");
+      c2 = c1;
+      c3 = new Cliente(2, "bb");
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+
+      //Setando o codigo apontado por c1 e c2
+      c2.setCodigo(3);
+      System.out.println("ATRIBUTOs:");
+      System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
+      System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
+      System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
+
+   }
+}

fonte/U0 - Nivelamento/java/ponteiro/Ponteiro05PassagemObjeto.java

@@ -0,0 +1,96 @@
+/**
+ * Ponteiro
+ * @author Max do Val Machado
+ * @version 3 01/2016
+ */
+class Cliente{
+   private int codigo;
+   private String nome;
+   public Cliente(){
+      this(0, "");
+   }
+   public Cliente(int codigo){
+      this(codigo, "");
+   }
+   public Cliente(int codigo, String nome){
+      this.codigo = codigo;
+      this.nome = nome;
+   }
+   public int getCodigo(){
+      return codigo;
+   }
+   public void setCodigo(int codigo){
+      this.codigo = codigo;
+   }
+   public String getNome(){
+      return nome;
+   }
+   public void setNome(String nome){
+      this.nome = nome;
+   }
+}
+
+class Ponteiro05PassagemObjeto { 
+
+   /**
+    * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o 
+    * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). 
+    * Depois, o metodo retorna o conteudo do nosso ponteiro (endereco recebido como parametro).
+    */
+   public static Cliente setar2(Cliente y){
+      y.setCodigo(6);
+      y.setNome("ff");
+      System.out.println("ADDRs: y(" + y + ")");
+      System.out.println("ATRIBUTOs: y(" + y.getCodigo() + " / " + y.getNome()+")");
+
+      return y;
+   }
+
+   /**
+    * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o 
+    * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). 
+    * Depois, o metodo faz com que o ponteiro corrente aponte para outro objeto (veja que c1 do metodo 
+    * princial continua apontando para o primeiro objeto). No final, a coleta de lixo do java libera a 
+    * area de memoria que continha o ponteiro e o objeto criados neste metodo.
+    */
+   public static void setar1(Cliente x){
+      x.setCodigo(4);
+      x.setNome("dd");
+      System.out.println("ADDRs: x(" + x + ")");
+      System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")");
+
+      x = new Cliente (5, "ee");
+      System.out.println("ADDRs: x(" + x + ")");
+      System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")");
+   }
+
+
+   public static void main (String[] args){
+
+      //Declarando tres ponteiros 
+      Cliente c1 = new Cliente(1, "aa");
+      Cliente c2 = c1;
+      Cliente c3 = new Cliente(2, "bb");
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+      System.out.println("ATRIBUTOs:");
+      System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
+      System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
+      System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
+
+      //Chamando o metodo setar1 e passando POR VALOR O ADDR de c1
+      setar1(c1);
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+      System.out.println("ATRIBUTOs:");
+      System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
+      System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
+      System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
+
+      //Chamando o metodo setar2, passando POR VALOR O ADDR DE c2 e retornando um novo endereco para C3
+      c3 = setar2(c2);
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+      System.out.println("ATRIBUTOs:");
+      System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
+      System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
+      System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
+   }
+}

fonte/U0 - Nivelamento/java/ponteiro/Ponteiro06PassagemObjetoClone.java

@@ -0,0 +1,99 @@
+/**
+ * Ponteiro
+ * @author Max do Val Machado
+ * @version 3 01/2016
+ */
+class Cliente{
+   private int codigo;
+   private String nome;
+   public Cliente(){
+      this(0, "");
+   }
+   public Cliente(int codigo){
+      this(codigo, "");
+   }
+   public Cliente(int codigo, String nome){
+      this.codigo = codigo;
+      this.nome = nome;
+   }
+   public int getCodigo(){
+      return codigo;
+   }
+   public void setCodigo(int codigo){
+      this.codigo = codigo;
+   }
+   public String getNome(){
+      return nome;
+   }
+   public void setNome(String nome){
+      this.nome = nome;
+   }
+   public Cliente clone(){
+      return new Cliente(this.codigo, this.nome);
+   }
+}
+
+class Ponteiro06PassagemObjetoClone {
+
+   /**
+    * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o 
+    * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). 
+    * Depois, o metodo retorna o conteudo do nosso ponteiro (endereco recebido como parametro).
+    */
+   public static Cliente setar2(Cliente y){
+      y.setCodigo(6);
+      y.setNome("ff");
+      System.out.println("ADDRs: y(" + y + ")");
+      System.out.println("ATRIBUTOs: y(" + y.getCodigo() + " / " + y.getNome()+")");
+
+      return y;
+   }
+
+   /**
+    * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o 
+    * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). 
+    * Depois, o metodo faz com que o ponteiro corrente aponte para outro objeto (veja que c1 do metodo 
+    * princial continua apontando para o primeiro objeto). No final, a coleta de lixo do java libera a 
+    * area de memoria que continha o ponteiro e o objeto criados neste metodo.
+    */
+   public static void setar1(Cliente x){
+      x.setCodigo(4);
+      x.setNome("dd");
+      System.out.println("ADDRs: x(" + x + ")");
+      System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")");
+
+      x = new Cliente (5, "ee");
+      System.out.println("ADDRs: x(" + x + ")");
+      System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")");
+   }
+
+
+   public static void main (String[] args){
+
+      //Declarando tres ponteiros 
+      Cliente c1 = new Cliente(1, "aa");
+      Cliente c2 = c1.clone();
+      Cliente c3 = new Cliente(2, "bb");
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+      System.out.println("ATRIBUTOs:");
+      System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
+      System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
+      System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
+
+      //Chamando o metodo setar1 e passando POR VALOR O ADDR de c1
+      setar1(c1);
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+      System.out.println("ATRIBUTOs:");
+      System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
+      System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
+      System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
+
+      //Chamando o metodo setar2, passando POR VALOR O ADDR DE c2 e retornando um novo endereco para C3
+      c3 = setar2(c2);
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+      System.out.println("ATRIBUTOs:");
+      System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
+      System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
+      System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
+   }
+}

fonte/U0 - Nivelamento/java/ponteiro/Ponteiro07ObjetoClone.java

@@ -0,0 +1,58 @@
+/**
+ * Ponteiro
+ * @author Max do Val Machado
+ * @version 3 01/2016
+ */
+class Cliente{
+   private int codigo;
+   private String nome;
+   public Cliente(){
+      this(0, "");
+   }
+   public Cliente(int codigo){
+      this(codigo, "");
+   }
+   public Cliente(int codigo, String nome){
+      this.codigo = codigo;
+      this.nome = nome;
+   }
+   public int getCodigo(){
+      return codigo;
+   }
+   public void setCodigo(int codigo){
+      this.codigo = codigo;
+   }
+   public String getNome(){
+      return nome;
+   }
+   public void setNome(String nome){
+      this.nome = nome;
+   }
+   public Cliente clone(){
+      return new Cliente(this.codigo, this.nome);
+   }
+}
+
+class Ponteiro07ObjetoClone {
+
+   public static void main (String[] args){
+
+      //Declarando tres ponteiros 
+      Cliente c1 = null, c2 = null, c3 = null;
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+
+      //Alocando areas de memoria (ou inicializando objetos) e apontando os ponteiros para tais areas
+      c1 = new Cliente(1, "aa");
+      c2 = c1;
+      c3 = new Cliente(2, "bb");
+      System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
+
+      //Setando o codigo apontado por c1 e c2
+      c2.setCodigo(3);
+      System.out.println("ATRIBUTOs:");
+      System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
+      System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
+      System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
+
+   }
+}

fonte/U0 - Nivelamento/java/recursividade/ChamandoMetodo.java

@@ -0,0 +1,20 @@
+class ChamandoMetodo {
+   public static void primeiro(){
+      System.out.println("1o - inicio");
+      segundo();
+      System.out.println("1o - fim");
+   }
+   public static void segundo(){
+      System.out.println("2o - inicio");
+      terceiro();
+      System.out.println("2o - fim");
+   }
+   public static void terceiro(){
+      System.out.println("3o - inicio e fim");
+   }
+   public static void main (String[] args){
+      System.out.println("main - inicio");
+      primeiro();
+      System.out.println("main - fim");
+   }
+}

fonte/U0 - Nivelamento/java/recursividade/ContarMaiuscula.java

@@ -0,0 +1,40 @@
+/**
+ * Recursividade
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class ContarMaiuscula {
+   public static boolean isUpper(char x){
+      return (x >= 'A' && x <= 'Z');
+   }
+
+   public static int contMaiusculo(String s){
+      int cont = 0;
+
+      for(int i = 0; i < s.length(); i++){
+         if(isUpper(s.charAt(i)) == true){
+            cont++;
+         }
+      }
+      return cont;
+   }
+   public static int contMaiusculo2(String s){
+      return contMaiusculo2(s, 0);
+   }
+   public static int contMaiusculo2(String s, int i){
+      int cont = 0;
+
+      if(i < s.length()){
+         if(isUpper(s.charAt(i)) == true){
+            cont++;
+         }
+         cont += contMaiusculo2(s, i + 1);
+      }
+      return cont;
+   }
+
+   public static void main (String[] args){
+      System.out.println("AlGoritmos e Estruturas de Dados: " + contMaiusculo("AlGoritmos e Estruturas de Dados"));
+      System.out.println("AlGoritmos e Estruturas de Dados: " + contMaiusculo2("AlGoritmos e Estruturas de Dados"));
+   }
+}

fonte/U0 - Nivelamento/java/recursividade/FatorialRecursivo.java

@@ -0,0 +1,20 @@
+/**
+ * Recursividade
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class FatorialRecursivo{
+   public static int fatorial(int n){
+      int resp;
+      System.out.println("fat (" + n + ")");
+      resp = (n == 1) ? 1 : n * fatorial(n-1);
+      System.out.println("fat n(" + n + "): " + resp);
+      return resp;
+   }
+
+   public static void main(String[] args){
+      int n = Integer.parseInt(args[0]);
+      System.out.println("FATORIAL RECURSIVO(" + n + "): " + fatorial(n));
+   }
+}
+

fonte/U0 - Nivelamento/java/recursividade/FibonacciRecursivo.java

@@ -0,0 +1,18 @@
+/**
+ * Recursividade
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class FibonacciRecursivo {
+   public static int fibRec (int n){
+      int resp;
+      System.out.println("fib (" + n + ")");
+      resp = (n == 0 || n == 1) ? 1 : fibRec(n-1) + fibRec(n-2);
+      System.out.println("fib (" + n + "): " + resp);
+      return resp;
+   }
+   public static void main (String[] args){
+      int n = Integer.parseInt(args[0]);
+      System.out.println("FIBONACCI RECURSIVO(" + n + "): " + fibRec(n));
+   }
+}

fonte/U0 - Nivelamento/java/recursividade/Multiplicacao.java

@@ -0,0 +1,31 @@
+class Multiplicacao {
+   public static int multiplicacao(int a, int b){
+      return multiplicacao(a, b, 0);
+   }
+
+   public static int multiplicacao(int a, int b, int i){
+      int resp = 0;
+
+      if(i < b){
+         resp = a + multiplicacao(a, b, i+1);
+      }
+
+      return resp;
+   }
+
+   public static int multiplicacaoInt(int a, int b){
+      int resp = 0;
+      for(int i = 0; i < b; i++){
+         resp = a + resp;
+      }
+      return resp;
+   }
+
+   public static void main (String[] args){
+      int mult = multiplicacaoInt(4, 3);
+      System.out.println("RESPOSTA INT: " + mult);
+
+      mult = multiplicacao(4, 3);
+      System.out.println("RESPOSTA REC: " + mult);
+   }
+}

fonte/U0 - Nivelamento/java/recursividade/PrintRecursivo.java

@@ -0,0 +1,18 @@
+/**
+ * Recursividade
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class PrintRecursivo{ 
+   public static void printRecursivo(int i){
+      System.out.println("valor de i: " + i);
+      if(i > 0){
+         printRecursivo(i-1);
+      }
+      System.out.println("valor de i: " + i);
+   }
+   public static void main(String[] args){
+      int n = Integer.parseInt(args[0]);
+      printRecursivo(n);
+   }
+}

fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao01.java

@@ -0,0 +1,12 @@
+/**
+ * Tratamento de excecao
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+public class TratamentoExcecao01 {
+   public static void main(String[] args) {
+      Integer i = new Integer(args[0]);
+      MyIO.println("A variavel i vale " + i);
+      MyIO.println("FIM DE PROGRAMA!!!");
+   }
+}

fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao02.java

@@ -0,0 +1,19 @@
+/**
+ * Tratamento de excecao
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+public class TratamentoExcecao02 {
+   public static void main(String[] args) {
+      try {
+         Integer i = new Integer(args[0]);
+         MyIO.println("A variavel i vale " + i);
+
+      } catch (ArrayIndexOutOfBoundsException e){
+         MyIO.println("Erro na passagem de parametros!!!");
+
+      } finally {
+         MyIO.println("FIM DE PROGRAMA!!!");
+      }
+   }
+}

fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao03.java

@@ -0,0 +1,22 @@
+/**
+ * Tratamento de excecao
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+public class TratamentoExcecao03 {
+   public static void main(String[] args) {
+      try {
+         Integer i = new Integer(args[0]);
+         MyIO.println("A variavel i vale " + i);
+
+      } catch (NumberFormatException e) {
+         MyIO.println("Erro de formatacao!!!");
+
+      } catch (ArrayIndexOutOfBoundsException e){
+         MyIO.println("Erro na passagem de parametros!!!");
+
+      } finally {
+         MyIO.println("FIM DE PROGRAMA!!!");
+      }
+   }
+}

fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao04.java

@@ -0,0 +1,37 @@
+/**
+ * Tratamento de excecao
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+public class TratamentoExcecao04 {
+   public static void metodo1(String s) throws NumberFormatException, ArrayIndexOutOfBoundsException {
+      Integer i = new Integer(s);
+      MyIO.println("A variavel i vale " + i);
+   }
+
+   public static void metodo2(String s) throws NumberFormatException {
+      Integer i = new Integer(s);
+      MyIO.println("A variavel i vale " + i);
+   }
+
+   public static void main(String[] args) {
+      try {
+         metodo1(args[0]);
+      } catch (NumberFormatException e) {
+         MyIO.println("Erro!!!");
+
+      } catch (ArrayIndexOutOfBoundsException e){
+         MyIO.println("Erro!!!");
+      }
+
+      MyIO.println("-------------->>>>>>>>    <<<<<<<<--------------");
+
+      try {
+         metodo2(args[0]);
+      } catch (NumberFormatException e) {
+         MyIO.println("Erro!!!");
+      }
+
+      MyIO.println("-------------->>>>>>>>    <<<<<<<<--------------");
+   }
+}

fonte/U0 - Nivelamento/java/tratamentoExcecao/TratamentoExcecao05.java

@@ -0,0 +1,22 @@
+/**
+ * Tratamento de excecao
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+public class TratamentoExcecao05 {
+   public static void metodo(int i) throws Exception {
+      if(i % 2 == 1){
+         throw new Exception ("Valor impar");
+      }
+   }
+
+   public static void main(String[] args) throws Exception {
+
+      int i = 2;
+      MyIO.println("-------------->>>>>>>>    <<<<<<<<--------------");
+      metodo(i);
+      MyIO.println("-------------->>>>>>>>    <<<<<<<<--------------");
+      metodo(++i);
+      MyIO.println("-------------->>>>>>>>    <<<<<<<<--------------");
+   }
+}

fonte/U3 - Fundamentos de análise de algoritmos/java/AND_OR.java

@@ -0,0 +1,19 @@
+class AND_OR {
+   public static boolean m1(){
+      System.out.println("m1");
+      return true;
+   }
+   public static boolean m2(){
+      System.out.println("m2");
+      return false;
+   }
+   public static void main (String[] args) {
+      System.out.println("=====================");
+      boolean or = m1() || m2();
+      System.out.println("OR: " + or);
+      System.out.println("=====================");
+      boolean and = m2() && m1();
+      System.out.println("AND: " + and);
+      System.out.println("=====================");
+   }
+}

fonte/U3 - Fundamentos de análise de algoritmos/java/Log.java

@@ -0,0 +1,17 @@
+class Log {
+   public static void main (String[] args) {
+      int[] n = {4,5,6,7,8,9,10,11,12,13,14,15,16,17,31,32,33,63,64,65};
+      int cont;
+
+      for(int k = 0; k < n.length; k++){
+         System.out.print("\n[n = " + n[k] + "] => ");
+         cont = 0;
+         for(int i = n[k]; i > 0; i /= 2){
+            System.out.print(" " + i);
+            cont++;
+         }
+         System.out.print(" (" + cont + " vezes)");
+      }
+      System.out.print("\n");
+   }
+}

fonte/U3 - Fundamentos de análise de algoritmos/java/Pesquisa.java

@@ -0,0 +1,61 @@
+class Pesquisa {
+   public static boolean pesqSeq(int[] vet, int x){
+      boolean resp = false;
+      int n = vet.length;
+
+      for(int i = 0; i < n; i++){
+         if(vet[i] == x){
+            resp = true;
+            i = n;
+         }
+      }
+      return resp;
+   }
+
+   public static boolean pesqBin(int[] vet, int x){
+      boolean resp = false;
+      int dir = (vet.length - 1), esq = 0, meio;
+
+      while (esq <= dir){
+         meio = (esq + dir) / 2;
+         if(x == vet[meio]){
+            resp = true;
+            esq = dir + 1;
+         } else if (x > vet[meio]) {
+            esq = meio + 1;
+         } else {
+            dir = meio - 1;
+         }
+      }
+      return resp;
+   }
+
+   public static boolean pesqBinRec(int[] vet, int x){
+      return pesqBinRec(vet, x, 0, (vet.length - 1));
+   }
+
+   public static boolean pesqBinRec(int[] vet, int x, int esq, int dir){
+      boolean resp;
+      int meio = (esq + dir) / 2;
+
+      if(esq > dir) {
+         resp = false;
+      } else if(x == vet[meio]){
+         resp = true;
+      } else if (x > vet[meio]) {
+         resp = pesqBinRec(vet, x, meio + 1, dir);
+      } else {
+         resp = pesqBinRec(vet, x, esq, meio - 1);
+      }
+      return resp;
+   }
+
+   public static void main (String[] args){
+      int[] vet = {2, 3, 5, 7, 9, 11, 15, 17, 20, 21, 30, 43, 49, 70, 71, 82};
+      int x = 35;
+
+      System.out.println("Pesquisa Sequencial: " + pesqSeq(vet, x));
+      System.out.println("Pesquisa Binária: " + pesqBin(vet, x));
+      System.out.println("Pesquisa Binária Recursiva: " + pesqBinRec(vet, x));
+   }
+}

fonte/U4 - Ordenação em memória principal/java/Bolha.java

@@ -0,0 +1,51 @@
+/**
+ * Metodo de ordenacao da bolha
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Bolha extends Geracao {
+
+	/**
+	 * Construtor.
+	 */
+   public Bolha(){
+      super();
+   }
+
+
+	/**
+	 * Construtor.
+	 * @param int tamanho do array de numeros inteiros.
+	 */
+   public Bolha(int tamanho){
+      super(tamanho);
+   }
+
+
+	/**
+	 * Algoritmo de ordenacao Bolha.
+	 */
+	public static void bolha() {
+		for (int i = (n - 1); i > 0; i--) {
+			for (int j = 0; j < i; j++) {
+				if (array[j] > array[j + 1]) {
+               swap(j, j+1);
+				}
+			}
+		}
+   }
+
+
+	public static void main(String[] args) {
+      Bolha bolha = new Bolha(100);
+		bolha.aleatorio();
+		bolha.mostrar();
+		
+		long comeco = now();
+		bolha.bolha();
+		long fim = now();
+		
+		bolha.mostrar();
+		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
+	}
+}

fonte/U4 - Ordenação em memória principal/java/Countingsort.java

@@ -0,0 +1,79 @@
+/**
+ * Metodo de ordenacao por contagem
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+
+class Countingsort extends Geracao {
+
+	/**
+	 * Construtor.
+	 */
+   public Countingsort(){
+      super();
+   }
+
+
+	/**
+	 * Construtor.
+	 * @param int tamanho do array de numeros inteiros.
+	 */
+   public Countingsort(int tamanho){
+      super(tamanho);
+   }
+
+
+	/**
+	 * Retorna o maior elemento do array.
+    * @return maior elemento
+	 */
+	public static int getMaior() {
+	   int maior = array[0];
+
+		for (int i = 0; i < n; i++) {
+         if(maior < array[i]){
+            maior = array[i];
+         }
+		}
+	   return maior;	
+	}
+
+
+	/**
+	 * Algoritmo de ordenacao Countingsort.
+	 */
+	public static void countingsort() {
+      //Array para contar o numero de ocorrencias de cada elemento
+      int[] count = new int[getMaior() + 1];
+      int[] ordenado = new int[n];
+
+      //Inicializar cada posicao do array de contagem 
+		for (int i = 0; i < count.length; count[i] = 0, i++);
+
+      //Agora, o count[i] contem o numero de elemento iguais a i
+      for (int i = 0; i < n; count[array[i]]++, i++);
+
+      //Agora, o count[i] contem o numero de elemento menores ou iguais a i
+      for(int i = 1; i < count.length; count[i] += count[i-1], i++);
+
+      //Ordenando
+      for(int i = n-1; i >= 0; ordenado[count[array[i]]-1] = array[i], count[array[i]]--, i--);
+
+      //Copiando para o array original
+      for(int i = 0; i < n; array[i] = ordenado[i], i++);
+   }
+
+
+	public static void main(String[] args) {
+      Countingsort countingsort = new Countingsort(100);
+		countingsort.aleatorio();
+		countingsort.mostrar();
+		
+		long comeco = now();
+		countingsort.countingsort();
+		long fim = now();
+		
+		countingsort.mostrar();
+		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
+	}
+}

fonte/U4 - Ordenação em memória principal/java/ExercicioDuvidaAND.java

@@ -0,0 +1,17 @@
+class ExercicioDuvidaAND {
+   public static boolean m1(){
+      System.out.println("m1");
+      return false;
+   }
+   public static boolean m2(){
+      System.out.println("m2");
+      return true;
+   }
+   public static void main (String[] args) {
+      System.out.println("inicio");
+      boolean and = m1() && m2();
+      System.out.println("============");
+      boolean or = m2() || m1();
+      System.out.println("fim: and(" + and + ") or (" + or + ")");
+   }
+}

fonte/U4 - Ordenação em memória principal/java/Geracao.java

@@ -0,0 +1,149 @@
+/**
+ * Geracao de elementos de um array
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+
+import java.util.*;
+
+class Geracao {
+   protected static int[] array;
+   protected static int n;
+
+
+	/**
+	 * Construtor.
+	 */
+   public Geracao(){
+      array = new int[100];
+      n = array.length;
+   }
+
+
+	/**
+	 * Construtor.
+	 * @param int tamanho do array de numeros inteiros.
+	 */
+   public Geracao(int tamanho){
+      array = new int[tamanho];
+      n = array.length;
+   }
+
+
+	/**
+	 * Produz um array ordenado de modo crescente.
+	 */
+	public static void crescente() {
+		for (int i = 0; i < n; i++) {
+			array[i] = i;
+		}
+	}
+
+	/**
+	 * Produz um array ordenado de modo decrescente.
+	 */
+	public static void decrescente() {
+		
+		for (int i = 0; i < n; i++) {
+			array[i] = n - 1 - i;
+		}
+	}
+
+	/**
+	 * Produz um array de numeros aleatorios.
+	 */
+	public static void aleatorio() {
+		Random gerador = new Random();
+		
+		for (int i = 0; i < n; i++) {
+			array[i] = Math.abs(gerador.nextInt()) % 1000; // 0 a 999
+		}
+	}
+
+
+	/**
+	 * Efetua a leitura dos elementos via entrada padrao.
+	 */
+	public static void entradaPadrao() {
+      n = MyIO.readInt();
+      array = new int[n];
+
+		for (int i = 0; i < n; i++) {
+			array[i] = MyIO.readInt();
+		}
+	}
+
+   public static void entrada(int[] vet){
+      n = vet.length;
+      array = new int[n];
+      for(int i = 0; i < n; i++){
+         array[i] = vet[i];
+      }
+   }
+
+
+	/**
+	 * Mostra os array de um array.
+	 * @param int k indica a quantidade de elementos do array a serem mostrados.
+	 */
+	public static void mostrar(int k) {
+		System.out.print("[ ");
+		
+		for (int i = 0; i < k; i++) {
+			System.out.print(array[i] + " ");
+		}
+		
+		System.out.println("] ");
+	}
+
+
+	/**
+	 * Mostra os array de um array.
+	 */
+   public static void mostrar() {
+      System.out.print("[ ");
+
+      for (int i = 0; i < n; i++) {
+         System.out.print("("+i+")" + array[i] + " ");
+      }
+
+      System.out.println("] ");
+   }
+
+
+   /**
+    * Troca o conteudo de duas posicoes do array
+    * @param i int primeira posicao
+    * @param j int segunda posicao
+    */
+   public static void swap(int i, int j) {
+      int temp = array[i];
+      array[i] = array[j];
+      array[j] = temp;
+   }
+
+
+   /**
+    * Retorna o timestamp atual
+    * @return timestamp atual
+    */
+   public static long now(){
+      return new Date().getTime();
+   }
+
+
+   /**
+    * Retorna verdadeiro/falso indicando se o array esta ordenado
+    * @return boolean indicando se o array esta ordenado
+    */
+   public static boolean isOrdenado(){
+      boolean resp = true;
+      for(int i = 1; i < n; i++){
+         if(array[i] < array[i-1]){
+            i = n;
+            resp = false;
+         }
+      }
+      return resp;
+   }
+}

fonte/U4 - Ordenação em memória principal/java/Heapsort.java

@@ -0,0 +1,100 @@
+/**
+ * Algoritmo de ordenacao Heapsort
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+
+class Heapsort extends Geracao {
+
+	/**
+	 * Construtor.
+	 */
+   public Heapsort(){
+      super();
+   }
+
+
+	/**
+	 * Construtor.
+	 * @param int tamanho do array de numeros inteiros.
+	 */
+   public Heapsort(int tamanho){
+      super(tamanho);
+   }
+
+
+   public static void constroi(int tamHeap){
+      for(int i = tamHeap; i > 1 && array[i] > array[i/2]; i /= 2){
+         swap(i, i/2);
+      }
+   }
+
+  public static void reconstroi(int tamHeap){
+      int i = 1;
+      while(i <= (tamHeap/2)){
+         int filho = getMaiorFilho(i, tamHeap);
+         if(array[i] < array[filho]){
+            swap(i, filho);
+            i = filho;
+         }else{
+            i = tamHeap;
+         }
+      }
+   }
+
+   public static int getMaiorFilho(int i, int tamHeap){
+      int filho;
+      if (2*i == tamHeap || array[2*i] > array[2*i+1]){
+         filho = 2*i;
+      } else {
+         filho = 2*i + 1;
+      }
+      return filho;
+   }
+
+	/**
+	 * Algoritmo de ordenacao Heapsort.
+	 */
+	public static void heapsort() {
+      //Alterar o vetor ignorando a posicao zero
+      int[] tmp = new int[n+1];
+      for(int i = 0; i < n; i++){
+         tmp[i+1] = array[i];
+      }
+      array = tmp;
+
+      //Contrucao do heap
+      for(int tamHeap = 2; tamHeap <= n; tamHeap++){
+         constroi(tamHeap);
+      }
+
+      //Ordenacao propriamente dita
+      int tamHeap = n;
+      while(tamHeap > 1){
+         swap(1, tamHeap--);
+         reconstroi(tamHeap);
+      }
+
+      //Alterar o vetor para voltar a posicao zero
+      tmp = array;
+      array = new int[n];
+      for(int i = 0; i < n; i++){
+         array[i] = tmp[i+1];
+      }
+   }
+
+
+	public static void main(String[] args) {
+      Heapsort heapsort = new Heapsort(200);
+		heapsort.aleatorio();
+		heapsort.mostrar();
+		
+		long comeco = now();
+		heapsort.heapsort();
+		long fim = now();
+		
+		//heapsort.mostrar();
+      System.out.println("Ordenado: " + heapsort.isOrdenado());
+		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
+	}
+}

fonte/U4 - Ordenação em memória principal/java/Insercao.java

@@ -0,0 +1,55 @@
+/**
+ * Algoritmo de ordenacao por insercao
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+
+class Insercao extends Geracao {
+
+	/**
+	 * Construtor.
+	 */
+   public Insercao(){
+      super();
+   }
+
+
+	/**
+	 * Construtor.
+	 * @param int tamanho do array de numeros inteiros.
+	 */
+   public Insercao(int tamanho){
+      super(tamanho);
+   }
+
+
+	/**
+	 * Algoritmo de ordenacao por insercao.
+	 */
+	public static void insercao() {
+		for (int i = 1; i < n; i++) {
+			int tmp = array[i];
+         int j = i - 1;
+
+         while ((j >= 0) && (array[j] > tmp)) {
+            array[j + 1] = array[j];
+            j--;
+         }
+         array[j + 1] = tmp;
+      }
+	}
+
+
+	public static void main(String[] args) {
+		Insercao insercao = new Insercao(1000000);
+		insercao.aleatorio();
+		//insercao.mostrar();
+
+		long comeco = now();
+		insercao.insercao();
+		long fim = now();
+
+		//insercao.mostrar();
+		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
+	}
+}

fonte/U4 - Ordenação em memória principal/java/Quicksort.java

@@ -0,0 +1,66 @@
+/**
+ * Algoritmo de ordenacao Quicksort
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Quicksort extends Geracao {
+
+	/**
+	 * Construtor.
+	 */
+   public Quicksort(){
+      super();
+   }
+
+
+	/**
+	 * Construtor.
+	 * @param int tamanho do array de numeros inteiros.
+	 */
+   public Quicksort(int tamanho){
+      super(tamanho);
+   }
+
+
+	/**
+	 * Algoritmo de ordenacao Quicksort.
+	 */
+	public static void quicksort() {
+      quicksort(0, n-1);
+   }
+
+	/**
+	 * Algoritmo de ordenacao Quicksort.
+    * @param int esq inicio do array a ser ordenado
+    * @param int dir fim do array a ser ordenado
+	 */
+    private static void quicksort(int esq, int dir) {
+        int i = esq, j = dir;
+        int pivo = array[(dir+esq)/2];
+        while (i <= j) {
+            while (array[i] < pivo) i++;
+            while (array[j] > pivo) j--;
+            if (i <= j) {
+                swap(i, j);
+                i++;
+                j--;
+            }
+        }
+        if (esq < j)  quicksort(esq, j);
+        if (i < dir)  quicksort(i, dir);
+    }
+ 
+
+	public static void main(String[] args) throws Exception {
+      Quicksort quicksort = new Quicksort(10000000);
+		quicksort.aleatorio();
+		//quicksort.mostrar();
+		
+		long comeco = now();
+		quicksort.quicksort();
+		long fim = now();
+
+		//quicksort.mostrar();
+		System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
+	}
+}

fonte/U4 - Ordenação em memória principal/java/Selecao.java

@@ -0,0 +1,54 @@
+/**
+ * Algoritmo de ordenacao por selecao
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+
+class Selecao extends Geracao {
+
+   /**
+    * Construtor.
+    */
+   public Selecao(){
+      super();
+   }
+
+
+   /**
+    * Construtor.
+    * @param int tamanho do array de numeros inteiros.
+    */
+   public Selecao(int tamanho){
+      super(tamanho);
+   }
+
+
+   /**
+    * Algoritmo de ordenacao por selecao.
+    */
+   public static void selecao() {
+      for (int i = 0; i < (n - 1); i++) {
+         int menor = i;
+         for (int j = (i + 1); j < n; j++){
+            if (array[menor] > array[j]){
+               menor = j;
+            }
+         }
+         swap(menor, i);
+      }
+   }
+
+
+   public static void main(String[] args) {
+      Selecao selecao = new Selecao(100);
+      selecao.aleatorio();
+      selecao.mostrar();
+
+      long comeco = now();
+      selecao.selecao();
+      long fim = now();
+
+      selecao.mostrar();
+      System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
+   }
+}

fonte/U4 - Ordenação em memória principal/java/Shellsort.java

@@ -0,0 +1,73 @@
+/**
+ * Algoritmo de ordenacao Shellsort
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+
+class Shellsort extends Geracao {
+
+   /**
+    * Construtor.
+    */
+   public Shellsort(){
+      super();
+   }
+
+
+   /**
+    * Construtor.
+    * @param int tamanho do array de numeros inteiros.
+    */
+   public Shellsort(int tamanho){
+      super(tamanho);
+   }
+
+
+   /**
+    * Algoritmo de ordenacao Shellsort.
+    */
+   public static void shellsort() {
+      int h = 1;
+
+      do { h = (h * 3) + 1; } while (h < n);
+
+      do {
+         h /= 3;
+         for(int cor = 0; cor < h; cor++){
+            insercaoPorCor(cor, h);
+         }
+      } while (h != 1);
+   }
+
+
+   /**
+    * Metodo que efetua a insercao nos pseudo-arrays do Shellsort.
+    * @param int cor cor do pseudo array.
+    * @param int h passo do shelsort
+    */
+   public static void insercaoPorCor(int cor, int h){
+      for (int i = (h + cor); i < n; i+=h) {
+         int tmp = array[i];
+         int j = i - h;
+         while ((j >= 0) && (array[j] > tmp)) {
+            array[j + h] = array[j];
+            j-=h;
+         }
+         array[j + h] = tmp;
+      }
+   }
+
+
+   public static void main(String[] args) {
+      Shellsort shellsort = new Shellsort(100000000);
+      shellsort.aleatorio();
+      //shellsort.mostrar();
+
+      long comeco = now();
+      shellsort.shellsort();
+      long fim = now();
+
+      //shellsort.mostrar();
+      System.out.println("Tempo para ordenar: " + (fim-comeco)/1000.0 + " s.");
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/c/coletalixo/coletalixo.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdlib.h>
+#define true 1
+
+typedef struct Celula {
+	int elemento;        // Elemento inserido na celula.
+	struct Celula* prox; // Aponta a celula prox.
+} Celula;
+
+Celula* novaCelula(int elemento) {
+   Celula* nova = (Celula*) malloc(sizeof(Celula));
+   nova->elemento = elemento;
+   nova->prox = NULL;
+   return nova;
+}
+
+Celula* primeiro;
+
+void start () {
+   primeiro = novaCelula(-1);
+}
+
+void inserir(int x) {
+   primeiro->prox = novaCelula(x);
+   Celula* tmp = primeiro;
+   primeiro = primeiro->prox;
+   free(tmp);
+}
+
+int main(int argc, char** argv) {
+   start();
+   while(true){
+      inserir(0);
+   }
+   return 0;
+}
+
+

fonte/U5 - Estruturas de dados lineares e flexíveis/c/fila/fila.c

@@ -0,0 +1,135 @@
+/**
+ * Fila dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <err.h>
+
+//TIPO CELULA ===================================================================
+typedef struct Celula {
+	int elemento;        // Elemento inserido na celula.
+	struct Celula* prox; // Aponta a celula prox.
+} Celula;
+
+Celula* novaCelula(int elemento) {
+   Celula* nova = (Celula*) malloc(sizeof(Celula));
+   nova->elemento = elemento;
+   nova->prox = NULL;
+   return nova;
+}
+
+//FILA PROPRIAMENTE DITA ========================================================
+Celula* primeiro;
+Celula* ultimo;
+
+
+/**
+ * Cria uma fila sem elementos (somente no cabeca).
+ */
+void start () {
+   primeiro = novaCelula(-1);
+   ultimo = primeiro;
+}
+
+
+/**
+ * Insere elemento na fila (politica FIFO).
+ * @param x int Elemento a inserir.
+ */
+void inserir(int x) {
+   ultimo->prox = novaCelula(x);
+   ultimo = ultimo->prox;
+}
+
+
+/**
+ * Remove elemento da fila (politica FIFO).
+ * @return Elemento removido.
+ */
+int remover() {
+   if (primeiro == ultimo) {
+      errx(1, "Erro ao remover!");
+   }
+   Celula* tmp = primeiro;
+   primeiro = primeiro->prox;
+   int resp = primeiro->elemento;
+   tmp->prox = NULL;
+   free(tmp);
+   tmp = NULL;
+   return resp;
+}
+
+
+/**
+ * Mostra os elementos separados por espacos.
+ */
+void mostrar() {
+   Celula* i;
+   printf("[ ");
+   for (i = primeiro->prox; i != NULL; i = i->prox) {
+      printf("%d ", i->elemento);
+   }
+   printf("] \n");
+}
+
+
+//METODO PRINCIPAL ==============================================================
+int main(int argc, char** argv){
+   int x1, x2, x3;
+   printf("\n==== FILA DINAMICA ====");
+
+   start();
+
+   inserir(5);
+   inserir(7);
+   inserir(8);
+   inserir(9);
+
+   printf("\nApos insercoes(5, 7, 8, 9): ");
+   mostrar();
+
+   x1 = remover();
+   x2 = remover();
+
+   printf("\nApos remocoes (%d, %d):", x1, x2);
+   mostrar();
+
+   inserir(3);
+   inserir(4);
+
+
+   printf("\nApos insercoes(3, 4): ");
+   mostrar();
+
+   x1 = remover();
+   x2 = remover();
+   x3 = remover();
+
+   printf("\nApos remocoes (%d, %d, %d):", x1, x2, x3);
+   mostrar();
+
+   inserir(4);
+   inserir(5);
+
+   printf("\nApos insercoes(4, 5): ");
+   mostrar();
+
+   x1 = remover();
+   x2 = remover();
+
+   printf("\nApos remocoes (%d, %d):", x1, x2);
+   mostrar();
+
+   inserir(6);
+   inserir(7);
+
+   printf("\nApos insercoes(6, 7): ");
+   mostrar();
+
+   x1 = remover();
+
+   printf("\nApos remocao (%d):", x1);
+   mostrar();
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/fila.c

@@ -0,0 +1,143 @@
+/**
+ * Lista estatica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAXTAM    6
+#define bool      short
+#define true      1
+#define false     0
+
+int array[MAXTAM+1];   // Elementos da pilha 
+int primeiro;          // Remove do indice "primeiro".
+int ultimo;             // Insere no indice "ultimo".
+
+
+/**
+ * Inicializacoes
+ */
+void start(){
+   primeiro = ultimo = 0;
+}
+
+
+/**
+ * Insere um elemento na ultima posicao da 
+ * @param x int elemento a ser inserido.
+ * @Se a fila estiver cheia.
+ */
+void inserir(int x) {
+
+   //validar insercao
+   if (((ultimo + 1) % MAXTAM) == primeiro) {
+      printf("Erro ao inserir!");
+      exit(1);
+   }
+
+   array[ultimo] = x;
+   ultimo = (ultimo + 1) % MAXTAM;
+}
+
+
+/**
+ * Remove um elemento da primeira posicao da fila e movimenta 
+ * os demais elementos para o primeiro da mesma.
+ * @return resp int elemento a ser removido.
+ * @Se a fila estiver vazia.
+ */
+int remover() {
+
+   //validar remocao
+   if (primeiro == ultimo) {
+      printf("Erro ao remover!");
+      exit(1);
+   }
+
+   int resp = array[primeiro];
+   primeiro = (primeiro + 1) % MAXTAM;
+   return resp;
+}
+
+
+/**
+ * Mostra os array separados por espacos.
+ */
+void mostrar (){
+   int i;
+   printf("\n[");
+
+   for(i = primeiro; i != ultimo; i = ((i + 1) % MAXTAM)) {
+      printf(" %d", array[i]);
+   }
+
+   printf(" ]");
+}
+
+
+/**
+ * Retorna um bool indicando se a fila esta vazia
+ * @return bool indicando se a fila esta vazia
+ */
+bool isVazia() {
+   return (primeiro == ultimo); 
+}
+
+
+int main(int argc, char** argv){
+   int x1, x2, x3;
+   printf("\n==== FILA ESTATICA ====");
+
+   inserir(5);
+   inserir(7);
+   inserir(8);
+   inserir(9);
+
+   printf("\nApos insercoes(5, 7, 8, 9): ");
+   mostrar();
+
+   x1 = remover();
+   x2 = remover();
+
+   printf("\nApos remocoes (%d, %d):", x1, x2);
+   mostrar();
+
+   inserir(3);
+   inserir(4);
+
+
+   printf("\nApos insercoes(3, 4): ");
+   mostrar();
+
+   x1 = remover();
+   x2 = remover();
+   x3 = remover();
+
+   printf("\nApos remocoes (%d, %d, %d):", x1, x2, x3);
+   mostrar();
+
+   inserir(4);
+   inserir(5);
+
+   printf("\nApos insercoes(4, 5): ");
+   mostrar();
+
+   x1 = remover();
+   x2 = remover();
+
+   printf("\nApos remocoes (%d, %d):", x1, x2);
+   mostrar();
+
+   inserir(6);
+   inserir(7);
+
+   printf("\nApos insercoes(6, 7): ");
+   mostrar();
+
+   x1 = remover();
+
+   printf("\nApos remocao (%d):", x1);
+   mostrar();
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/c/linear/lista.c

@@ -0,0 +1,215 @@
+/**
+ * Lista estatica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAXTAM    6
+#define bool      short
+#define true      1
+#define false     0
+
+int array[MAXTAM];   // Elementos da pilha 
+int n;               // Quantidade de array.
+
+
+/**
+ * Inicializacoes
+ */
+void start(){
+   n = 0;
+}
+
+
+/**
+ * Insere um elemento na primeira posicao da lista e move os demais
+ * elementos para o fim da 
+ * @param x int elemento a ser inserido.
+ */
+void inserirInicio(int x) {
+   int i;
+
+   //validar insercao
+   if(n >= MAXTAM){
+      printf("Erro ao inserir!");
+      exit(1);
+   } 
+
+   //levar elementos para o fim do array
+   for(i = n; i > 0; i--){
+      array[i] = array[i-1];
+   }
+
+   array[0] = x;
+   n++;
+}
+
+
+/**
+ * Insere um elemento na ultima posicao da 
+ * @param x int elemento a ser inserido.
+ */
+void inserirFim(int x) {
+
+   //validar insercao
+   if(n >= MAXTAM){
+      printf("Erro ao inserir!");
+      exit(1);
+   }
+
+   array[n] = x;
+   n++;
+}
+
+
+/**
+ * Insere um elemento em uma posicao especifica e move os demais
+ * elementos para o fim da 
+ * @param x int elemento a ser inserido.
+ * @param pos Posicao de insercao.
+ */
+void inserir(int x, int pos) {
+   int i;
+
+   //validar insercao
+   if(n >= MAXTAM || pos < 0 || pos > n){
+      printf("Erro ao inserir!");
+      exit(1);
+   }
+
+   //levar elementos para o fim do array
+   for(i = n; i > pos; i--){
+      array[i] = array[i-1];
+   }
+
+   array[pos] = x;
+   n++;
+}
+
+
+/**
+ * Remove um elemento da primeira posicao da lista e movimenta 
+ * os demais elementos para o inicio da mesma.
+ * @return resp int elemento a ser removido.
+ */
+int removerInicio() {
+   int i, resp;
+
+   //validar remocao
+   if (n == 0) {
+      printf("Erro ao remover!");
+      exit(1);
+   }
+
+   resp = array[0];
+   n--;
+
+   for(i = 0; i < n; i++){
+      array[i] = array[i+1];
+   }
+
+   return resp;
+}
+
+
+/**
+ * Remove um elemento da ultima posicao da 
+ * @return resp int elemento a ser removido.
+ */
+int removerFim() {
+
+   //validar remocao
+   if (n == 0) {
+      printf("Erro ao remover!");
+      exit(1);
+   }
+
+   return array[--n];
+}
+
+
+/**
+ * Remove um elemento de uma posicao especifica da lista e 
+ * movimenta os demais elementos para o inicio da mesma.
+ * @param pos Posicao de remocao.
+ * @return resp int elemento a ser removido.
+ */
+int remover(int pos) {
+   int i, resp;
+
+   //validar remocao
+   if (n == 0 || pos < 0 || pos >= n) {
+      printf("Erro ao remover!");
+      exit(1);
+   }
+
+   resp = array[pos];
+   n--;
+
+   for(i = pos; i < n; i++){
+      array[i] = array[i+1];
+   }
+
+   return resp;
+}
+
+
+/**
+ * Mostra os array separados por espacos.
+ */
+void mostrar (){
+   int i;
+
+   printf("[ ");
+
+   for(i = 0; i < n; i++){
+      printf("%d ", array[i]);
+   }
+
+   printf("]\n");
+}
+
+
+/**
+ * Procura um array e retorna se ele existe.
+ * @param x int elemento a ser pesquisado.
+ * @return <code>true</code> se o array existir,
+ * <code>false</code> em caso contrario.
+ */
+bool pesquisar(int x) {
+   bool retorno = false;
+   int i;
+
+   for (i = 0; i < n && retorno == false; i++) {
+      retorno = (array[i] == x);
+   }
+   return retorno;
+}
+
+
+int main(int argc, char** argv){
+   int x1, x2, x3;
+
+   printf("==== LISTA ESTATICA ====\n");
+
+   start();
+
+   inserirInicio(1);
+   inserirInicio(0);
+   inserirFim(2);
+   inserirFim(3);
+   inserir(4, 3);
+   inserir(5, 2);
+
+   printf("Apos insercoes: ");
+   mostrar();
+
+   x1 = removerInicio();
+   x2 = removerFim();
+   x3 = remover(2);
+
+   printf("Apos remocoes (%d, %d, %d): ", x1, x2, x3);
+   mostrar();
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/c/listadupla/listadupla.c

@@ -0,0 +1,267 @@
+/**
+ * Lista dupla dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <err.h>
+
+#define bool   short
+#define true   1
+#define false  0
+
+//TIPO CELULA ===================================================================
+typedef struct CelulaDupla {
+	int elemento;        // Elemento inserido na celula.
+	struct CelulaDupla* prox; // Aponta a celula prox.
+   struct CelulaDupla* ant;  // Aponta a celula anterior.
+} CelulaDupla;
+
+CelulaDupla* novaCelulaDupla(int elemento) {
+   CelulaDupla* nova = (CelulaDupla*) malloc(sizeof(CelulaDupla));
+   nova->elemento = elemento;
+   nova->ant = nova->prox = NULL;
+   return nova;
+}
+
+//LISTA PROPRIAMENTE DITA =======================================================
+CelulaDupla* primeiro;
+CelulaDupla* ultimo;
+
+
+/**
+ * Cria uma lista dupla sem elementos (somente no cabeca).
+ */
+void start () {
+   primeiro = novaCelulaDupla(-1);
+   ultimo = primeiro;
+}
+
+
+/**
+ * Insere um elemento na primeira posicao da lista.
+ * @param x int elemento a ser inserido.
+ */
+void inserirInicio(int x) {
+   CelulaDupla* tmp = novaCelulaDupla(x);
+
+   tmp->ant = primeiro;
+   tmp->prox = primeiro->prox;
+   primeiro->prox = tmp;
+   if (primeiro == ultimo) {                    
+      ultimo = tmp;
+   } else {
+      tmp->prox->ant = tmp;
+   }
+   tmp = NULL;
+}
+
+
+/**
+ * Insere um elemento na ultima posicao da lista.
+ * @param x int elemento a ser inserido.
+ */
+void inserirFim(int x) {
+   ultimo->prox = novaCelulaDupla(x);
+   ultimo->prox->ant = ultimo;
+   ultimo = ultimo->prox;
+}
+
+
+/**
+ * Remove um elemento da primeira posicao da lista.
+ * @return resp int elemento a ser removido.
+ */
+int removerInicio() {
+   if (primeiro == ultimo) {
+      errx(1, "Erro ao remover (vazia)!");
+   }
+
+   CelulaDupla* tmp = primeiro;
+   primeiro = primeiro->prox;
+   int resp = primeiro->elemento;
+   tmp->prox = primeiro->ant = NULL;
+   free(tmp);
+   tmp = NULL;
+   return resp;
+}
+
+
+/**
+ * Remove um elemento da ultima posicao da lista.
+ * @return resp int elemento a ser removido.
+ */
+int removerFim() {
+   if (primeiro == ultimo) {
+      errx(1, "Erro ao remover (vazia)!");
+   } 
+   int resp = ultimo->elemento;
+   ultimo = ultimo->ant;
+   ultimo->prox->ant = NULL;
+   free(ultimo->prox);
+   ultimo->prox = NULL;
+   return resp;
+}
+
+
+/**
+ *  Calcula e retorna o tamanho, em numero de elementos, da lista.
+ *  @return resp int tamanho
+ */
+int tamanho() {
+   int tamanho = 0; 
+   CelulaDupla* i;
+   for(i = primeiro; i != ultimo; i = i->prox, tamanho++);
+   return tamanho;
+}
+
+
+/**
+ * Insere um elemento em uma posicao especifica considerando que o 
+ * primeiro elemento valido esta na posicao 0.
+ * @param x int elemento a ser inserido.
+ * @param pos int posicao da insercao.
+ * @throws Exception Se <code>posicao</code> invalida.
+ */
+void inserir(int x, int pos) {
+
+   int tam = tamanho();
+
+   if(pos < 0 || pos > tam){
+      errx(1, "Erro ao remover (posicao %d/%d invalida!", pos, tam);
+   } else if (pos == 0){
+      inserirInicio(x);
+   } else if (pos == tam){
+      inserirFim(x);
+   } else {
+      // Caminhar ate a posicao anterior a insercao
+      CelulaDupla* i = primeiro;
+      int j;
+      for(j = 0; j < pos; j++, i = i->prox);
+
+      CelulaDupla* tmp = novaCelulaDupla(x);
+      tmp->ant = i;
+      tmp->prox = i->prox;
+      tmp->ant->prox = tmp->prox->ant = tmp;
+      tmp = i = NULL;
+   }
+}
+
+
+/**
+ * Remove um elemento de uma posicao especifica da lista
+ * considerando que o primeiro elemento valido esta na posicao 0.
+ * @param posicao Meio da remocao.
+ * @return resp int elemento a ser removido.
+ * @throws Exception Se <code>posicao</code> invalida.
+ */
+int remover(int pos) {
+   int resp;
+   int tam = tamanho();
+
+   if (primeiro == ultimo){
+      errx(1, "Erro ao remover (vazia)!");
+   } else if(pos < 0 || pos >= tam){
+      errx(1, "Erro ao remover (posicao %d/%d invalida!", pos, tam);
+   } else if (pos == 0){
+      resp = removerInicio();
+   } else if (pos == tam - 1){
+      resp = removerFim();
+   } else {
+      // Caminhar ate a posicao anterior a insercao
+      CelulaDupla* i = primeiro->prox;
+      int j;
+      for(j = 0; j < pos; j++, i = i->prox);
+
+      i->ant->prox = i->prox;
+      i->prox->ant = i->ant;
+      resp = i->elemento;
+      i->prox = i->ant = NULL;
+      free(i);
+      i = NULL;
+   }
+
+   return resp;
+}
+
+
+/**
+ * Mostra os elementos da lista separados por espacos.
+ */
+void mostrar() {
+   CelulaDupla* i;
+   printf("[ ");
+   for (i = primeiro->prox; i != NULL; i = i->prox) {
+      printf("%d ", i->elemento);
+   }
+   printf("] \n");
+}
+
+
+/**
+ * Mostra os elementos da lista de forma invertida 
+ * e separados por espacos.
+ */
+void mostrarInverso() {
+   printf("[ ");
+   CelulaDupla* i;
+   for (i = ultimo; i != primeiro; i = i->ant){
+      printf("%d ", i->elemento);
+   }
+   printf("] \n"); // Termina de mostrar.
+}
+
+
+/**
+ * Procura um elemento e retorna se ele existe.
+ * @param x Elemento a pesquisar.
+ * @return <code>true</code> se o elemento existir,
+ * <code>false</code> em caso contrario.
+ */
+bool pesquisar(int x) {
+   bool resp = false;
+   CelulaDupla* i;
+
+   for (i = primeiro->prox; i != NULL; i = i->prox) {
+      if(i->elemento == x){
+         resp = true;
+         i = ultimo;
+      }
+   }
+   return resp;
+}
+
+
+int main(int argc, char** argv) {
+   start();
+
+   printf("LISTA DINAMICA DUPLAMENTE ENCADEADA\n\n");
+
+   inserirInicio(2);
+   inserirInicio(1);
+   inserirFim(5);
+   inserirFim(6);
+   inserir(3, 2);
+   inserir(4, 3);
+   inserir(7, 6);
+   inserir(0, 0);
+   inserirFim(8);
+   inserirFim(9);
+
+   printf("Apos insercoes: ");
+   mostrar();
+   mostrarInverso();
+
+   remover(3);
+   remover(2);
+   removerFim();
+   removerInicio();
+   remover(0);
+   remover(4);
+
+   printf("Apos remocoes: ");
+   mostrar();
+   mostrarInverso();
+   return 0;
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/c/listasimples/lista.c

@@ -0,0 +1,248 @@
+/**
+ * Lista simples dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <err.h>
+#define bool   short
+#define true   1
+#define false  0
+
+//TIPO CELULA ===================================================================
+typedef struct Celula {
+	int elemento;        // Elemento inserido na celula.
+	struct Celula* prox; // Aponta a celula prox.
+} Celula;
+
+Celula* novaCelula(int elemento) {
+   Celula* nova = (Celula*) malloc(sizeof(Celula));
+   nova->elemento = elemento;
+   nova->prox = NULL;
+   return nova;
+}
+
+//LISTA PROPRIAMENTE DITA =======================================================
+Celula* primeiro;
+Celula* ultimo;
+
+
+/**
+ * Cria uma lista sem elementos (somente no cabeca).
+ */
+void start () {
+   primeiro = novaCelula(-1);
+   ultimo = primeiro;
+}
+
+
+/**
+ * Insere um elemento na primeira posicao da lista.
+ * @param x int elemento a ser inserido.
+ */
+void inserirInicio(int x) {
+   Celula* tmp = novaCelula(x);
+   tmp->prox = primeiro->prox;
+   primeiro->prox = tmp;
+   if (primeiro == ultimo) {                    
+      ultimo = tmp;
+   }
+   tmp = NULL;
+}
+
+/**
+ * Insere um elemento na ultima posicao da lista.
+ * @param x int elemento a ser inserido.
+ */
+void inserirFim(int x) {
+   ultimo->prox = novaCelula(x);
+   ultimo = ultimo->prox;
+}
+
+
+/**
+ * Remove um elemento da primeira posicao da lista.
+ * @return resp int elemento a ser removido.
+ * @throws Exception Se a lista nao contiver elementos.
+ */
+int removerInicio() {
+   if (primeiro == ultimo) {
+      errx(1, "Erro ao remover!");
+   }
+
+   Celula* tmp = primeiro;
+   primeiro = primeiro->prox;
+   int resp = primeiro->elemento;
+   tmp->prox = NULL;
+   free(tmp);
+   tmp = NULL;
+   return resp;
+}
+
+
+/**
+ * Remove um elemento da ultima posicao da lista.
+ * @return resp int elemento a ser removido.
+ */
+int removerFim() {
+   if (primeiro == ultimo) {
+      errx(1, "Erro ao remover!");
+   } 
+
+   // Caminhar ate a penultima celula:
+   Celula* i;
+   for(i = primeiro; i->prox != ultimo; i = i->prox);
+
+   int resp = ultimo->elemento;
+   ultimo = i;
+   free(ultimo->prox);
+   i = ultimo->prox = NULL;
+
+   return resp;
+}
+
+
+/**
+ * Calcula e retorna o tamanho, em numero de elementos, da lista.
+ * @return resp int tamanho
+ */
+int tamanho() {
+   int tamanho = 0;
+   Celula* i;
+   for(i = primeiro; i != ultimo; i = i->prox, tamanho++);
+   return tamanho;
+}
+
+
+/**
+ * Insere um elemento em uma posicao especifica considerando que o 
+ * primeiro elemento valido esta na posicao 0.
+ * @param x int elemento a ser inserido.
+ * @param pos int posicao da insercao.
+ * @throws Exception Se <code>posicao</code> invalida.
+ */
+void inserir(int x, int pos) {
+
+   int tam = tamanho();
+
+   if(pos < 0 || pos > tam){
+      errx(1, "Erro ao inserir posicao (%d/ tamanho = %d) invalida!", pos, tam);
+   } else if (pos == 0){
+      inserirInicio(x);
+   } else if (pos == tam){
+      inserirFim(x);
+   } else {
+      // Caminhar ate a posicao anterior a insercao
+      int j;
+      Celula* i = primeiro;
+      for(j = 0; j < pos; j++, i = i->prox);
+
+      Celula* tmp = novaCelula(x);
+      tmp->prox = i->prox;
+      i->prox = tmp;
+      tmp = i = NULL;
+   }
+}
+
+
+/**
+ * Remove um elemento de uma posicao especifica da lista
+ * considerando que o primeiro elemento valido esta na posicao 0.
+ * @param posicao Meio da remocao.
+ * @return resp int elemento a ser removido.
+ * @throws Exception Se <code>posicao</code> invalida.
+ */
+int remover(int pos) {
+   int resp;
+   int tam = tamanho();
+
+   if (primeiro == ultimo){
+      errx(1, "Erro ao remover (vazia)!");
+   } else if(pos < 0 || pos >= tam){
+      errx(1, "Erro ao remover posicao (%d/ tamanho = %d) invalida!", pos, tam);
+   } else if (pos == 0){
+      resp = removerInicio();
+   } else if (pos == tam - 1){
+      resp = removerFim();
+   } else {
+      // Caminhar ate a posicao anterior a insercao
+      Celula* i = primeiro;
+      int j;
+      for(j = 0; j < pos; j++, i = i->prox);
+
+      Celula* tmp = i->prox;
+      resp = tmp->elemento;
+      i->prox = tmp->prox;
+      tmp->prox = NULL;
+      free(tmp);
+      i = tmp = NULL;
+   }
+   return resp;
+}
+
+
+/**
+ * Mostra os elementos da lista separados por espacos.
+ */
+void mostrar() {
+   printf("[ ");
+   Celula* i;
+   for (i = primeiro->prox; i != NULL; i = i->prox) {
+      printf("%d ", i->elemento);
+   }
+   printf("] \n");
+}
+
+
+/**
+ * Procura um elemento e retorna se ele existe.
+ * @param x Elemento a pesquisar.
+ * @return <code>true</code> se o elemento existir,
+ * <code>false</code> em caso contrario.
+ */
+bool pesquisar(int x) {
+   bool retorno = false;
+   Celula* i;
+
+   for (i = primeiro->prox; i != NULL; i = i->prox) {
+      if(i->elemento == x){
+         retorno = true;
+         i = ultimo;
+      }
+   }
+   return retorno;
+}
+
+
+int main(int argc, char** argv) {
+   int x1, x2, x3, x4, x5, x6;
+   printf("=== LISTA DINAMICA SIMPLESMENTE ENCADEADA === \n\n");
+
+   start();
+
+   inserirInicio(1);
+   inserirInicio(0);
+   inserirFim(4);
+   inserirFim(5);
+   inserir(2, 2);
+   inserir(3, 3);
+   inserir(6, 6);
+   inserir(-1, 0);
+   inserirFim(7);
+   inserirFim(8);
+
+   printf("Apos insercoes: ");
+   mostrar();
+
+   x1 = remover(3);
+   x2 = remover(2);
+   x3 = removerFim();
+   x4 = removerInicio();
+   x5 = remover(0);
+   x6 = remover(4);
+
+   printf("Apos remocoes (%d, %d, %d, %d, %d, %d): ", x1, x2, x3, x4, x5, x6);
+   mostrar();
+   return 0;
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/c/matriz/entrada.in

@@ -0,0 +1,37 @@
+quantidade de testes (por exemplo, 3)
+linhas da primeira matriz do primeiro teste
+colunas da primeira matriz do primeiro teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da segunda matriz do primeiro teste
+colunas da segunda matriz do primeiro teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da primeira matriz do segundo teste
+colunas da primeira matriz do segundo teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da segunda matriz do segundo teste
+colunas da segunda matriz do segundo teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da primeira matriz do terceiro teste
+colunas da primeira matriz do terceiro teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da segunda matriz do terceiro teste
+colunas da segunda matriz do terceiro teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x

fonte/U5 - Estruturas de dados lineares e flexíveis/c/pilha/pilha.c

@@ -0,0 +1,103 @@
+/**
+ * Pilha dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <err.h>
+
+//TIPO CELULA ===================================================================
+typedef struct Celula {
+	int elemento;        // Elemento inserido na celula.
+	struct Celula* prox; // Aponta a celula prox.
+} Celula;
+
+Celula* novaCelula(int elemento) {
+   Celula* nova = (Celula*) malloc(sizeof(Celula));
+   nova->elemento = elemento;
+   nova->prox = NULL;
+   return nova;
+}
+
+//PILHA PROPRIAMENTE DITA =======================================================
+Celula* topo; // Sem celula cabeca.
+
+
+/**
+ * Cria uma fila sem elementos.
+ */
+void start () {
+   topo = NULL;
+}
+
+
+/**
+ * Insere elemento na pilha (politica FILO).
+ * @param x int elemento a inserir.
+ */
+void inserir(int x) {
+   Celula* tmp = novaCelula(x);
+   tmp->prox = topo;
+   topo = tmp;
+   tmp = NULL;
+}
+
+/**
+ * Remove elemento da pilha (politica FILO).
+ * @return Elemento removido.
+ */
+int remover() {
+   if (topo == NULL) {
+      errx(1, "Erro ao remover!");
+   }
+
+   int resp = topo->elemento;
+   Celula* tmp = topo;
+   topo = topo->prox;
+   tmp->prox = NULL;
+   free(tmp);
+   tmp = NULL;
+   return resp;
+}
+
+
+/**
+ * Mostra os elementos separados por espacos, comecando do topo.
+ */
+void mostrar() {
+   Celula* i;
+   printf("[");
+   for(i = topo; i != NULL; i = i->prox) {
+      printf("%d ,", i->elemento);
+   }
+
+   printf("] \n");
+}
+
+
+//METODO PRINCIPAL ==============================================================
+int main(int argc, char** argv){
+   int x1, x2, x3;
+
+   printf("==== PILHA FLEXIVEL ====\n");
+
+   start();
+
+   inserir(0);
+   inserir(1);
+   inserir(2);
+   inserir(3);
+   inserir(4);
+   inserir(5);
+
+   printf("Apos insercoes: \n");
+   mostrar();
+
+   x1 = remover();
+   x2 = remover();
+   x3 = remover();
+
+   printf("Apos as remocoes (%d, %d, %d) \n ", x1, x2, x3);
+   mostrar();
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/Celula.java

@@ -0,0 +1,26 @@
+/**
+ * Celula (pilha, lista e fila dinamica)
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Celula {
+	public int elemento; // Elemento inserido na celula.
+	public Celula prox; // Aponta a celula prox.
+
+
+	/**
+	 * Construtor da classe.
+	 */
+	public Celula() {
+		this(0);
+	}
+
+	/**
+	 * Construtor da classe.
+	 * @param elemento int inserido na celula.
+	 */
+	public Celula(int elemento) {
+      this.elemento = elemento;
+      this.prox = null;
+	}
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/coletalixo/ColetaLixo.java

@@ -0,0 +1,24 @@
+
+
+class ColetaLixo {
+	private Celula primeiro;
+
+	public ColetaLixo () {
+		primeiro = new Celula();
+	}
+
+	public void inserir(int x) {
+		primeiro.prox = new Celula(x);
+		primeiro = primeiro.prox;
+	}
+
+	public static void main (String [] args) {
+		ColetaLixo coletaLixo = new ColetaLixo ();
+
+		while(true){
+			coletaLixo.inserir(0);
+		}
+	}
+}
+
+

fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Celula.java

@@ -0,0 +1,26 @@
+/**
+ * Celula (pilha, lista e fila dinamica)
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Celula {
+	public int elemento; // Elemento inserido na celula.
+	public Celula prox; // Aponta a celula prox.
+
+
+	/**
+	 * Construtor da classe.
+	 */
+	public Celula() {
+		this(0);
+	}
+
+	/**
+	 * Construtor da classe.
+	 * @param elemento int inserido na celula.
+	 */
+	public Celula(int elemento) {
+      this.elemento = elemento;
+      this.prox = null;
+	}
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/Fila.java

@@ -0,0 +1,61 @@
+/**
+ * Fila dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+public class Fila {
+	private Celula primeiro;
+	private Celula ultimo;
+
+
+	/**
+	 * Construtor da classe que cria uma fila sem elementos (somente no cabeca).
+	 */
+	public Fila() {
+		primeiro = new Celula();
+		ultimo = primeiro;
+	}
+
+
+	/**
+	 * Insere elemento na fila (politica FIFO).
+	 * @param x int elemento a inserir.
+	 */
+	public void inserir(int x) {
+		ultimo.prox = new Celula(x);
+		ultimo = ultimo.prox;
+	}
+
+
+	/**
+	 * Remove elemento da fila (politica FIFO).
+	 * @return Elemento removido.
+	 * @trhows Exception Se a fila nao tiver elementos.
+	 */
+	public int remover() throws Exception {
+		if (primeiro == ultimo) {
+			throw new Exception("Erro ao remover!");
+		}
+
+      Celula tmp = primeiro;
+		primeiro = primeiro.prox;
+		int resp = primeiro.elemento;
+      tmp.prox = null;
+      tmp = null;
+		return resp;
+	}
+
+
+	/**
+	 * Mostra os elementos separados por espacos.
+	 */
+	public void mostrar() {
+		System.out.print("[ ");
+		
+		for(Celula i = primeiro.prox; i != null; i = i.prox) {
+			System.out.print(i.elemento + " ");
+		}
+		
+		System.out.println("] ");
+	}
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/fila/PrincipalFila.java

@@ -0,0 +1,63 @@
+/**
+ * Fila dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class PrincipalFila {
+   public static void main(String[] args) throws Exception {
+      System.out.println("==== FILA DINAMICA ====");
+      Fila fila = new Fila();
+      int x1, x2, x3;
+
+      fila.inserir(5);
+      fila.inserir(7);
+      fila.inserir(8);
+      fila.inserir(9);
+
+      System.out.println("Apos insercoes(5, 7, 8, 9): ");
+      fila.mostrar();
+
+      x1 = fila.remover();
+      x2 = fila.remover();
+
+      System.out.println("Apos remocoes (" + x1 + ", " + x2 + "):");
+      fila.mostrar();
+
+      fila.inserir(3);
+      fila.inserir(4);
+
+
+      System.out.println("Apos insercoes(3, 4): ");
+      fila.mostrar();
+
+      x1 = fila.remover();
+      x2 = fila.remover();
+      x3 = fila.remover();
+
+      System.out.println("Apos remocoes (" + x1 + ", " + x2 + ", " + x3 + "):");
+      fila.mostrar();
+
+      fila.inserir(4);
+      fila.inserir(5);
+
+      System.out.println("Apos insercoes(4, 5): ");
+      fila.mostrar();
+
+      x1 = fila.remover();
+      x2 = fila.remover();
+
+      System.out.println("Apos remocoes (" + x1 + ", " + x2 + "):");
+      fila.mostrar();
+
+      fila.inserir(6);
+      fila.inserir(7);
+
+      System.out.println("Apos insercoes(6, 7): ");
+      fila.mostrar();
+
+      x1 = fila.remover();
+
+      System.out.println("Apos remocao (" + x1 + "): ");
+      fila.mostrar();
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila.java

@@ -0,0 +1,100 @@
+/**
+ * Fila estatica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Fila {
+   private int[] array;
+   private int primeiro; // Remove do indice "primeiro".
+   private int ultimo; // Insere no indice "ultimo".
+
+
+   /**
+    * Construtor da classe.
+    */
+   public Fila () {
+      this(6);
+   }
+
+
+   /**
+    * Construtor da classe.
+    * @param tamanho Tamanho da fila.
+    */
+   public Fila (int tamanho){
+      array = new int[tamanho+1];
+      primeiro = ultimo = 0;
+   }
+
+
+   /**
+    * Insere um elemento na ultima posicao da fila.
+    * @param x int elemento a ser inserido.
+    * @throws Exception Se a fila estiver cheia.
+    */
+   public void inserir(int x) throws Exception {
+
+      //validar insercao
+      if (((ultimo + 1) % array.length) == primeiro) {
+         throw new Exception("Erro ao inserir!");
+      }
+
+      array[ultimo] = x;
+      ultimo = (ultimo + 1) % array.length;
+   }
+
+
+   /**
+    * Remove um elemento da primeira posicao da fila e movimenta 
+    * os demais elementos para o primeiro da mesma.
+    * @return resp int elemento a ser removido.
+    * @throws Exception Se a fila estiver vazia.
+    */
+   public int remover() throws Exception {
+
+      //validar remocao
+      if (primeiro == ultimo) {
+         throw new Exception("Erro ao remover!");
+      }
+
+      int resp = array[primeiro];
+      primeiro = (primeiro + 1) % array.length;
+      return resp;
+   }
+
+
+   /**
+    * Mostra os array separados por espacos.
+    */
+   public void mostrar (){
+      System.out.print("[ ");
+
+      for(int i = primeiro; i != ultimo; i = ((i + 1) % array.length)) {
+         System.out.print(array[i] + " ");
+      }
+
+      System.out.println("]");
+   }
+
+   public void mostrarRec(){
+      System.out.print("[ ");
+      mostrarRec(primeiro);
+      System.out.println("]");
+   }
+
+   public void mostrarRec(int i){
+      if(i != ultimo){
+         System.out.print(array[i] + " ");
+         mostrarRec((i + 1) % array.length);
+      }
+   }
+
+
+   /**
+    * Retorna um boolean indicando se a fila esta vazia
+    * @return boolean indicando se a fila esta vazia
+    */
+   public boolean isVazia() {
+      return (primeiro == ultimo); 
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Fila2Pilha.java

@@ -0,0 +1,56 @@
+/**
+ * Fila 2 Pilha
+ * @author Felipe Cunha
+ * @version 1 1/2017
+ */
+
+ public class Fila2Pilha{
+
+   private Fila f1, f2;
+
+   public Fila2Pilha(){
+     f1 = new Fila(6);
+     f2 = new Fila(6);
+   }
+
+   public Fila2Pilha(int tamanho){
+     f1 = new Fila (tamanho);
+     f2 = new Fila (tamanho);
+   }
+
+   public void empilhar(int elemento) throws Exception {
+     while(!f1.isVazia()){
+       f2.inserir(f1.remover());
+     }
+
+     f1.inserir(elemento);
+
+     while(!f2.isVazia()){
+       f1.inserir(f2.remover());
+     }
+   }
+
+   public int desempilhar() throws Exception {
+     return f1.remover();
+   }
+
+   public void mostrar(){
+     f1.mostrar();
+   }
+
+   public boolean isVazia(){
+     return f1.isVazia();
+   }
+
+   public static void main(String []args) throws Exception{
+     Fila2Pilha p1 = new Fila2Pilha();
+
+     p1.empilhar(10);
+     p1.empilhar(11);
+     p1.empilhar(15);
+     p1.empilhar(20);
+
+     p1.mostrar();
+
+   }
+ }

fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/Lista.java

@@ -0,0 +1,183 @@
+/**
+ * Lista estatica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Lista {
+   private int[] array;
+   private int n;
+
+
+   /**
+    * Construtor da classe.
+    */
+   public Lista () {
+      this(6);
+   }
+
+
+   /**
+    * Construtor da classe.
+    * @param tamanho Tamanho da lista.
+    */
+   public Lista (int tamanho){
+      array = new int[tamanho];
+      n = 0;
+   }
+
+
+   /**
+    * Insere um elemento na primeira posicao da lista e move os demais
+    * elementos para o fim da lista.
+    * @param x int elemento a ser inserido.
+    * @throws Exception Se a lista estiver cheia.
+    */
+   public void inserirInicio(int x) throws Exception {
+
+      //validar insercao
+      if(n >= array.length){
+         throw new Exception("Erro ao inserir!");
+      } 
+
+      //levar elementos para o fim do array
+      for(int i = n; i > 0; i--){
+         array[i] = array[i-1];
+      }
+
+      array[0] = x;
+      n++;
+   }
+
+
+   /**
+    * Insere um elemento na ultima posicao da lista.
+    * @param x int elemento a ser inserido.
+    * @throws Exception Se a lista estiver cheia.
+    */
+   public void inserirFim(int x) throws Exception {
+
+      //validar insercao
+      if(n >= array.length){
+         throw new Exception("Erro ao inserir!");
+      }
+
+      array[n] = x;
+      n++;
+   }
+
+
+   /**
+    * Insere um elemento em uma posicao especifica e move os demais
+    * elementos para o fim da lista.
+    * @param x int elemento a ser inserido.
+    * @param pos Posicao de insercao.
+    * @throws Exception Se a lista estiver cheia ou a posicao invalida.
+    */
+   public void inserir(int x, int pos) throws Exception {
+
+      //validar insercao
+      if(n >= array.length || pos < 0 || pos > n){
+         throw new Exception("Erro ao inserir!");
+      }
+
+      //levar elementos para o fim do array
+      for(int i = n; i > pos; i--){
+         array[i] = array[i-1];
+      }
+
+      array[pos] = x;
+      n++;
+   }
+
+
+   /**
+    * Remove um elemento da primeira posicao da lista e movimenta 
+    * os demais elementos para o inicio da mesma.
+    * @return resp int elemento a ser removido.
+    * @throws Exception Se a lista estiver vazia.
+    */
+   public int removerInicio() throws Exception {
+
+      //validar remocao
+      if (n == 0) {
+         throw new Exception("Erro ao remover!");
+      }
+
+      int resp = array[0];
+      n--;
+
+      for(int i = 0; i < n; i++){
+         array[i] = array[i+1];
+      }
+
+      return resp;
+   }
+
+
+   /**
+    * Remove um elemento da ultima posicao da lista.
+    * @return resp int elemento a ser removido.
+    * @throws Exception Se a lista estiver vazia.
+    */
+   public int removerFim() throws Exception {
+
+      //validar remocao
+      if (n == 0) {
+         throw new Exception("Erro ao remover!");
+      }
+
+      return array[--n];
+   }
+
+
+   /**
+    * Remove um elemento de uma posicao especifica da lista e 
+    * movimenta os demais elementos para o inicio da mesma.
+    * @param pos Posicao de remocao.
+    * @return resp int elemento a ser removido.
+    * @throws Exception Se a lista estiver vazia ou a posicao for invalida.
+    */
+   public int remover(int pos) throws Exception {
+
+      //validar remocao
+      if (n == 0 || pos < 0 || pos >= n) {
+         throw new Exception("Erro ao remover!");
+      }
+
+      int resp = array[pos];
+      n--;
+
+      for(int i = pos; i < n; i++){
+         array[i] = array[i+1];
+      }
+
+      return resp;
+   }
+
+
+   /**
+    * Mostra os elementos da lista separados por espacos.
+    */
+   public void mostrar (){
+      System.out.print("[ ");
+      for(int i = 0; i < n; i++){
+         System.out.print(array[i] + " ");
+      }
+      System.out.println("]");
+   }
+
+
+   /**
+    * Procura um elemento e retorna se ele existe.
+    * @param x int elemento a ser pesquisado.
+    * @return <code>true</code> se o array existir,
+    * <code>false</code> em caso contrario.
+    */
+   public boolean pesquisar(int x) {
+      boolean retorno = false;
+      for (int i = 0; i < n && retorno == false; i++) {
+         retorno = (array[i] == x);
+      }
+      return retorno;
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/ListaOrdenada.java

@@ -0,0 +1,156 @@
+/**
+ * Lista estatica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class ListaOrdenada {
+   private int[] array;
+   private int n;
+
+
+   /**
+    * Construtor da classe.
+    */
+   public ListaOrdenada () {
+      this(6);
+   }
+
+
+   /**
+    * Construtor da classe.
+    * @param tamanho Tamanho da lista.
+    */
+   public ListaOrdenada (int tamanho){
+      array = new int[tamanho];
+      n = 0;
+   }
+
+
+   /**
+    * Insere um elemento 
+    * @param x int elemento a ser inserido.
+    * @throws Exception Se a lista estiver cheia ou a posicao invalida.
+    */
+   public void inserir(int x) throws Exception {
+
+      //validar insercao
+      if(n >= array.length){
+         throw new Exception("Erro ao inserir!");
+      }
+
+      //procurar a posicao de insercao e movimentando os demais elementos para o fim do array
+      int pos;
+      for(pos = n-1; pos >= 0 && array[pos] > x; pos--){
+         array[pos+1] = array[pos];
+      }
+      array[pos+1] = x;
+      n++;
+   }
+
+   /**
+    * Retorna verdadeiro/falso indicando se o array esta ordenado
+    * @return boolean indicando se o array esta ordenado
+    */
+   public boolean isOrdenado(){
+      boolean resp = true;
+      for(int i = 1; i < n; i++){
+         if(array[i] < array[i-1]){
+            i = n;
+            resp = false;
+         }
+      }
+      return resp;
+   }
+
+
+   /**
+    * Remove um elemento da primeira posicao da lista e movimenta 
+    * os demais elementos para o inicio da mesma.
+    * @return resp int elemento a ser removido.
+    * @throws Exception Se a lista estiver vazia.
+    */
+   public int removerInicio() throws Exception {
+
+      //validar remocao
+      if (n == 0) {
+         throw new Exception("Erro ao remover!");
+      }
+
+      int resp = array[0];
+      n--;
+
+      for(int i = 0; i < n; i++){
+         array[i] = array[i+1];
+      }
+
+      return resp;
+   }
+
+
+   /**
+    * Remove um elemento da ultima posicao da lista.
+    * @return resp int elemento a ser removido.
+    * @throws Exception Se a lista estiver vazia.
+    */
+   public int removerFim() throws Exception {
+
+      //validar remocao
+      if (n == 0) {
+         throw new Exception("Erro ao remover!");
+      }
+
+      return array[--n];
+   }
+
+
+   /**
+    * Remove um elemento de uma posicao especifica da lista e 
+    * movimenta os demais elementos para o inicio da mesma.
+    * @param pos Posicao de remocao.
+    * @return resp int elemento a ser removido.
+    * @throws Exception Se a lista estiver vazia ou a posicao for invalida.
+    */
+   public int remover(int pos) throws Exception {
+
+      //validar remocao
+      if (n == 0 || pos < 0 || pos >= n) {
+         throw new Exception("Erro ao remover!");
+      }
+
+      int resp = array[pos];
+      n--;
+
+      for(int i = pos; i < n; i++){
+         array[i] = array[i+1];
+      }
+
+      return resp;
+   }
+
+
+   /**
+    * Mostra os elementos da lista separados por espacos.
+    */
+   public void mostrar (){
+      System.out.print("[ ");
+      for(int i = 0; i < n; i++){
+         System.out.print(array[i] + " ");
+      }
+      System.out.println("]");
+   }
+
+
+   /**
+    * Procura um elemento e retorna se ele existe.
+    * @param x int elemento a ser pesquisado.
+    * @return <code>true</code> se o array existir,
+    * <code>false</code> em caso contrario.
+    */
+   public boolean pesquisar(int x) {
+      boolean retorno = false;
+      for (int i = 0; i < n && retorno == false; i++) {
+         retorno = (array[i] == x);
+      }
+      return retorno;
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalFila.java

@@ -0,0 +1,63 @@
+/**
+ * Fila estatica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class PrincipalFila {
+   public static void main(String[] args) throws Exception {
+      System.out.println("==== FILA ESTATICA ====");
+      Fila fila = new Fila();
+      int x1, x2, x3;
+
+      fila.inserir(5);
+      fila.inserir(7);
+      fila.inserir(8);
+      fila.inserir(9);
+
+      System.out.println("Apos insercoes(5, 7, 8, 9): ");
+      fila.mostrar();
+
+      x1 = fila.remover();
+      x2 = fila.remover();
+
+      System.out.println("Apos remocoes (" + x1 + ", " + x2 + "):");
+      fila.mostrar();
+
+      fila.inserir(3);
+      fila.inserir(4);
+
+
+      System.out.println("Apos insercoes(3, 4): ");
+      fila.mostrar();
+
+      x1 = fila.remover();
+      x2 = fila.remover();
+      x3 = fila.remover();
+
+      System.out.println("Apos remocoes (" + x1 + ", " + x2 + ", " + x3 + "):");
+      fila.mostrar();
+
+      fila.inserir(4);
+      fila.inserir(5);
+
+      System.out.println("Apos insercoes(4, 5): ");
+      fila.mostrar();
+
+      x1 = fila.remover();
+      x2 = fila.remover();
+
+      System.out.println("Apos remocoes (" + x1 + ", " + x2 + "):");
+      fila.mostrar();
+
+      fila.inserir(6);
+      fila.inserir(7);
+
+      System.out.println("Apos insercoes(6, 7): ");
+      fila.mostrar();
+
+      x1 = fila.remover();
+
+      System.out.println("Apos remocao (" + x1 + "): ");
+      fila.mostrar();
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalLista.java

@@ -0,0 +1,29 @@
+/**
+ * Lista estatica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class PrincipalLista {
+   public static void main(String[] args) throws Exception {
+      System.out.println("==== LISTA ESTATICA ====");
+      Lista lista = new Lista();
+      int x1, x2, x3;
+
+      lista.inserirInicio(1);
+      lista.inserirInicio(0);
+      lista.inserirFim(2);
+      lista.inserirFim(3);
+      lista.inserir(4, 3);
+      lista.inserir(5, 2);
+
+      System.out.print("Apos insercoes: ");
+      lista.mostrar();
+
+      x1 = lista.removerInicio();
+      x2 = lista.removerFim();
+      x3 = lista.remover(2);
+
+      System.out.print("Apos remocoes (" + x1 + ", " + x2 + ", " + x3 + "):");
+      lista.mostrar();
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/linear/PrincipalListaOrdenada.java

@@ -0,0 +1,21 @@
+import java.util.*;
+/**
+ * Lista estatica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class PrincipalListaOrdenada {
+   public static void main(String[] args) throws Exception {
+		Random gerador = new Random();
+      System.out.println("==== LISTA ESTATICA ====");
+      ListaOrdenada lista = new ListaOrdenada(1000);
+
+      for(int i = 0; i < 1000; i++){
+         lista.inserir(Math.abs(gerador.nextInt()) % 1000);
+      }
+
+      System.out.print("Apos insercoes: ");
+      lista.mostrar();
+      System.out.print("Ordenada: " +  lista.isOrdenado());
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/CelulaDupla.java

@@ -0,0 +1,27 @@
+/**
+ * Celula Dupla (lista dupla dinamica)
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class CelulaDupla {
+	public int elemento;
+	public CelulaDupla ant;
+	public CelulaDupla prox;
+
+	/**
+	 * Construtor da classe.
+	 */
+	public CelulaDupla() {
+		this(0);
+	}
+
+
+	/**
+	 * Construtor da classe.
+	 * @param elemento int inserido na celula.
+	 */
+	public CelulaDupla(int elemento) {
+		this.elemento = elemento;
+		this.ant = this.prox = null;
+	}
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/ListaDupla.java

@@ -0,0 +1,204 @@
+/**
+ * Lista dupla dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class ListaDupla {
+	private CelulaDupla primeiro;
+	private CelulaDupla ultimo;
+
+
+	/**
+	 * Construtor da classe que cria uma lista dupla sem elementos (somente no cabeca).
+	 */
+	public ListaDupla() {
+		primeiro = new CelulaDupla();
+		ultimo = primeiro;
+	}
+
+
+	/**
+	 * Insere um elemento na primeira posicao da lista.
+    * @param x int elemento a ser inserido.
+	 */
+	public void inserirInicio(int x) {
+		CelulaDupla tmp = new CelulaDupla(x);
+
+      tmp.ant = primeiro;
+      tmp.prox = primeiro.prox;
+      primeiro.prox = tmp;
+      if(primeiro == ultimo){
+         ultimo = tmp;
+      }else{
+         tmp.prox.ant = tmp;
+      }
+      tmp = null;
+	}
+
+
+	/**
+	 * Insere um elemento na ultima posicao da lista.
+    * @param x int elemento a ser inserido.
+	 */
+	public void inserirFim(int x) {
+		ultimo.prox = new CelulaDupla(x);
+      ultimo.prox.ant = ultimo;
+		ultimo = ultimo.prox;
+	}
+
+
+	/**
+	 * Remove um elemento da primeira posicao da lista.
+    * @return resp int elemento a ser removido.
+	 * @throws Exception Se a lista nao contiver elementos.
+	 */
+	public int removerInicio() throws Exception {
+		if (primeiro == ultimo) {
+			throw new Exception("Erro ao remover (vazia)!");
+		}
+
+      CelulaDupla tmp = primeiro;
+		primeiro = primeiro.prox;
+		int resp = primeiro.elemento;
+      tmp.prox = primeiro.ant = null;
+      tmp = null;
+		return resp;
+	}
+
+
+	/**
+	 * Remove um elemento da ultima posicao da lista.
+    * @return resp int elemento a ser removido.
+	 * @throws Exception Se a lista nao contiver elementos.
+	 */
+	public int removerFim() throws Exception {
+		if (primeiro == ultimo) {
+			throw new Exception("Erro ao remover (vazia)!");
+		} 
+      int resp = ultimo.elemento;
+      ultimo = ultimo.ant;
+      ultimo.prox.ant = null;
+      ultimo.prox = null;
+		return resp;
+	}
+
+
+	/**
+    * Insere um elemento em uma posicao especifica considerando que o 
+    * primeiro elemento valido esta na posicao 0.
+    * @param x int elemento a ser inserido.
+	 * @param pos int posicao da insercao.
+	 * @throws Exception Se <code>posicao</code> invalida.
+	 */
+   public void inserir(int x, int pos) throws Exception {
+
+      int tamanho = tamanho();
+
+      if(pos < 0 || pos > tamanho){
+			throw new Exception("Erro ao inserir posicao (" + pos + " / tamanho = " + tamanho + ") invalida!");
+      } else if (pos == 0){
+         inserirInicio(x);
+      } else if (pos == tamanho){
+         inserirFim(x);
+      } else {
+		   // Caminhar ate a posicao anterior a insercao
+         CelulaDupla i = primeiro;
+         for(int j = 0; j < pos; j++, i = i.prox);
+		
+         CelulaDupla tmp = new CelulaDupla(x);
+         tmp.ant = i;
+         tmp.prox = i.prox;
+         tmp.ant.prox = tmp.prox.ant = tmp;
+         tmp = i = null;
+      }
+   }
+
+
+	/**
+    * Remove um elemento de uma posicao especifica da lista
+    * considerando que o primeiro elemento valido esta na posicao 0.
+	 * @param posicao Meio da remocao.
+    * @return resp int elemento a ser removido.
+	 * @throws Exception Se <code>posicao</code> invalida.
+	 */
+	public int remover(int pos) throws Exception {
+      int resp;
+      int tamanho = tamanho();
+
+		if (primeiro == ultimo){
+			throw new Exception("Erro ao remover (vazia)!");
+
+      } else if(pos < 0 || pos >= tamanho){
+			throw new Exception("Erro ao remover (posicao " + pos + " / " + tamanho + " invalida!");
+      } else if (pos == 0){
+         resp = removerInicio();
+      } else if (pos == tamanho - 1){
+         resp = removerFim();
+      } else {
+		   // Caminhar ate a posicao anterior a insercao
+         CelulaDupla i = primeiro.prox;
+         for(int j = 0; j < pos; j++, i = i.prox);
+		
+         i.ant.prox = i.prox;
+         i.prox.ant = i.ant;
+         resp = i.elemento;
+         i.prox = i.ant = null;
+         i = null;
+      }
+
+		return resp;
+	}
+
+
+	/**
+	 * Mostra os elementos da lista separados por espacos.
+	 */
+	public void mostrar() {
+		System.out.print("[ "); // Comeca a mostrar.
+		for (CelulaDupla i = primeiro.prox; i != null; i = i.prox) {
+			System.out.print(i.elemento + " ");
+		}
+		System.out.println("] "); // Termina de mostrar.
+	}
+
+
+	/**
+	 * Mostra os elementos da lista de forma invertida 
+    * e separados por espacos.
+	 */
+	public void mostrarInverso() {
+		System.out.print("[ ");
+		for (CelulaDupla i = ultimo; i != primeiro; i = i.ant){
+			System.out.print(i.elemento + " ");
+      }
+		System.out.println("] "); // Termina de mostrar.
+	}
+
+
+	/**
+	 * Procura um elemento e retorna se ele existe.
+	 * @param x Elemento a pesquisar.
+	 * @return <code>true</code> se o elemento existir,
+	 * <code>false</code> em caso contrario.
+	 */
+	public boolean pesquisar(int x) {
+		boolean resp = false;
+		for (CelulaDupla i = primeiro.prox; i != null; i = i.prox) {
+         if(i.elemento == x){
+            resp = true;
+            i = ultimo;
+         }
+		}
+		return resp;
+	}
+
+	/**
+	 * Calcula e retorna o tamanho, em numero de elementos, da lista.
+	 * @return resp int tamanho
+	 */
+   public int tamanho() {
+      int tamanho = 0; 
+      for(CelulaDupla i = primeiro; i != ultimo; i = i.prox, tamanho++);
+      return tamanho;
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/listadupla/PrincipalListaDupla.java

@@ -0,0 +1,40 @@
+/**
+ * Lista dupla dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class PrincipalListaDupla {
+	public static void main(String[] args) {
+		try {
+			System.out.println("=== LISTA DINAMICA DUPLAMENTE ENCADEADA ===");
+			ListaDupla lista = new ListaDupla();
+
+			lista.inserirInicio(1);
+			lista.inserirInicio(0);
+			lista.inserirFim(4);
+			lista.inserirFim(5);
+			lista.inserir(2, 2);
+			lista.inserir(3, 3);
+			lista.inserir(6, 6);
+			lista.inserir(-1, 0);
+			lista.inserirFim(7);
+			lista.inserirFim(8);
+
+			System.out.print("Apos insercoes: ");
+			lista.mostrar();
+
+			int x1 = lista.remover(3);
+			int x2 = lista.remover(2);
+			int x3 = lista.removerFim();
+			int x4 = lista.removerInicio();
+			int x5 = lista.remover(0);
+			int x6 = lista.remover(4);
+
+			System.out.print("Apos remocoes (" +x1+ ", " +x2+ ", " +x3+ ", " +x4+ ", " +x5+ ", " +x6+ "): ");
+			lista.mostrar();
+		}
+		catch(Exception erro) {
+			System.out.println(erro.getMessage());
+		}
+	}
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Celula.java

@@ -0,0 +1,26 @@
+/**
+ * Celula (pilha, lista e fila dinamica)
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Celula {
+	public int elemento; // Elemento inserido na celula.
+	public Celula prox; // Aponta a celula prox.
+
+
+	/**
+	 * Construtor da classe.
+	 */
+	public Celula() {
+		this(0);
+	}
+
+	/**
+	 * Construtor da classe.
+	 * @param elemento int inserido na celula.
+	 */
+	public Celula(int elemento) {
+      this.elemento = elemento;
+      this.prox = null;
+	}
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/Lista.java

@@ -0,0 +1,188 @@
+/**
+ * Lista dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Lista {
+	private Celula primeiro;
+	private Celula ultimo;
+
+
+	/**
+	 * Construtor da classe que cria uma lista sem elementos (somente no cabeca).
+	 */
+	public Lista() {
+		primeiro = new Celula();
+		ultimo = primeiro;
+	}
+
+
+	/**
+	 * Insere um elemento na primeira posicao da lista.
+    * @param x int elemento a ser inserido.
+	 */
+	public void inserirInicio(int x) {
+		Celula tmp = new Celula(x);
+      tmp.prox = primeiro.prox;
+		primeiro.prox = tmp;
+		if (primeiro == ultimo) {                 
+			ultimo = tmp;
+		}
+      tmp = null;
+	}
+
+
+	/**
+	 * Insere um elemento na ultima posicao da lista.
+    * @param x int elemento a ser inserido.
+	 */
+	public void inserirFim(int x) {
+		ultimo.prox = new Celula(x);
+		ultimo = ultimo.prox;
+	}
+
+
+	/**
+	 * Remove um elemento da primeira posicao da lista.
+    * @return resp int elemento a ser removido.
+	 * @throws Exception Se a lista nao contiver elementos.
+	 */
+	public int removerInicio() throws Exception {
+		if (primeiro == ultimo) {
+			throw new Exception("Erro ao remover (vazia)!");
+		}
+
+      Celula tmp = primeiro;
+		primeiro = primeiro.prox;
+		int resp = primeiro.elemento;
+      tmp.prox = null;
+      tmp = null;
+		return resp;
+	}
+
+
+	/**
+	 * Remove um elemento da ultima posicao da lista.
+    * @return resp int elemento a ser removido.
+	 * @throws Exception Se a lista nao contiver elementos.
+	 */
+	public int removerFim() throws Exception {
+		if (primeiro == ultimo) {
+			throw new Exception("Erro ao remover (vazia)!");
+		} 
+
+		// Caminhar ate a penultima celula:
+      Celula i;
+      for(i = primeiro; i.prox != ultimo; i = i.prox);
+
+      int resp = ultimo.elemento; 
+      ultimo = i; 
+      i = ultimo.prox = null;
+      
+		return resp;
+	}
+
+
+	/**
+    * Insere um elemento em uma posicao especifica considerando que o 
+    * primeiro elemento valido esta na posicao 0.
+    * @param x int elemento a ser inserido.
+	 * @param pos int posicao da insercao.
+	 * @throws Exception Se <code>posicao</code> invalida.
+	 */
+   public void inserir(int x, int pos) throws Exception {
+
+      int tamanho = tamanho();
+
+      if(pos < 0 || pos > tamanho){
+			throw new Exception("Erro ao inserir posicao (" + pos + " / tamanho = " + tamanho + ") invalida!");
+      } else if (pos == 0){
+         inserirInicio(x);
+      } else if (pos == tamanho){
+         inserirFim(x);
+      } else {
+		   // Caminhar ate a posicao anterior a insercao
+         Celula i = primeiro;
+         for(int j = 0; j < pos; j++, i = i.prox);
+		
+         Celula tmp = new Celula(x);
+         tmp.prox = i.prox;
+         i.prox = tmp;
+         tmp = i = null;
+      }
+   }
+
+
+	/**
+    * Remove um elemento de uma posicao especifica da lista
+    * considerando que o primeiro elemento valido esta na posicao 0.
+	 * @param posicao Meio da remocao.
+    * @return resp int elemento a ser removido.
+	 * @throws Exception Se <code>posicao</code> invalida.
+	 */
+	public int remover(int pos) throws Exception {
+      int resp;
+      int tamanho = tamanho();
+
+		if (primeiro == ultimo){
+			throw new Exception("Erro ao remover (vazia)!");
+
+      } else if(pos < 0 || pos >= tamanho){
+			throw new Exception("Erro ao remover (posicao " + pos + " / " + tamanho + " invalida!");
+      } else if (pos == 0){
+         resp = removerInicio();
+      } else if (pos == tamanho - 1){
+         resp = removerFim();
+      } else {
+		   // Caminhar ate a posicao anterior a insercao
+         Celula i = primeiro;
+         for(int j = 0; j < pos; j++, i = i.prox);
+		
+         Celula tmp = i.prox;
+         resp = tmp.elemento;
+         i.prox = tmp.prox;
+         tmp.prox = null;
+         i = tmp = null;
+      }
+
+		return resp;
+	}
+
+	/**
+	 * Mostra os elementos da lista separados por espacos.
+	 */
+	public void mostrar() {
+		System.out.print("[ ");
+		for (Celula i = primeiro.prox; i != null; i = i.prox) {
+			System.out.print(i.elemento + " ");
+		}
+		System.out.println("] ");
+	}
+
+	/**
+	 * Procura um elemento e retorna se ele existe.
+	 * @param x Elemento a pesquisar.
+	 * @return <code>true</code> se o elemento existir,
+	 * <code>false</code> em caso contrario.
+	 */
+	public boolean pesquisar(int x) {
+		boolean resp = false;
+		for (Celula i = primeiro.prox; i != null; i = i.prox) {
+         if(i.elemento == x){
+            resp = true;
+            i = ultimo;
+         }
+		}
+		return resp;
+	}
+
+	/**
+	 * Calcula e retorna o tamanho, em numero de elementos, da lista.
+	 * @return resp int tamanho
+	 */
+   public int tamanho() {
+      int tamanho = 0; 
+      for(Celula i = primeiro; i != ultimo; i = i.prox, tamanho++);
+      return tamanho;
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/listasimples/PrincipalLista.java

@@ -0,0 +1,41 @@
+/**
+ * Lista simples dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class PrincipalLista {
+	public static void main(String[] args) {
+		try {
+			System.out.println("=== LISTA DINAMICA SIMPLESMENTE ENCADEADA ===");
+			Lista lista = new Lista();
+
+			lista.inserirInicio(1);
+			lista.inserirInicio(0);
+			lista.inserirFim(4);
+			lista.inserirFim(5);
+			lista.inserir(2, 2);
+			lista.inserir(3, 3);
+			lista.inserir(6, 6);
+			lista.inserir(-1, 0);
+			lista.inserirFim(7);
+			lista.inserirFim(8);
+
+			System.out.print("Apos insercoes: ");
+			lista.mostrar();
+
+			int x1 = lista.remover(3);
+			int x2 = lista.remover(2);
+			int x3 = lista.removerFim();
+			int x4 = lista.removerInicio();
+			int x5 = lista.remover(0);
+			int x6 = lista.remover(4);
+			lista.inserirFim(9);
+
+			System.out.print("Apos remocoes (" +x1+ ", " +x2+ ", " +x3+ ", " +x4+ ", " +x5+ ", " +x6+ "): ");
+			lista.mostrar();
+		}
+		catch(Exception erro) {
+			System.out.println(erro.getMessage());
+		}
+	}
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Celula.java

@@ -0,0 +1,20 @@
+class Celula {
+   private int elemento;
+   private Celula inf, sup, esq, dir;
+
+   public Celula(){
+      this(0, null, null, null, null);
+   }
+
+   public Celula(int elemento){
+      this(elemento, null, null, null, null);
+   }
+
+   public Celula(int elemento, Celula inf, Celula sup, Celula esq, Celula dir){
+      this.elemento = elemento;
+      this.inf = inf;
+      this.sup = sup;
+      this.esq = esq;
+      this.dir = dir;
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Matriz.java

@@ -0,0 +1,53 @@
+class Matriz {
+   private Celula inicio;
+   private int linha, coluna;
+
+   public Matriz (){
+      this.linha = this.coluna = 3;
+
+      //alocar a matriz com this.linha linhas e this.coluna colunas
+   }
+
+   public Matriz (int linha, int coluna){
+      this.linha = linha;
+      this.coluna = coluna;
+
+      //alocar a matriz com this.linha linhas e this.coluna colunas
+   }
+
+   public Matriz soma (Matriz m) {
+      Matriz resp = null;
+
+      if(this.linha == m.linha && this.coluna == m.coluna){
+         //...
+      }
+
+      return resp;
+   }
+
+   public Matriz multiplicacao (Matriz m) {
+      Matriz resp = null;
+
+      if(){
+         //...
+      }
+
+      return resp;
+   }
+
+   public boolean isQuadrada(){
+      boolean (this.linha == this.coluna);
+   }
+
+   public void mostrarDiagonalPrincipal (){
+      if(isQuadrada() == true){
+
+      }
+   }
+
+   public void mostrarDiagonalSecundaria (){
+      if(isQuadrada() == true){
+
+      }
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/Principal.java

@@ -0,0 +1,30 @@
+class Principal {
+
+   public static void main(String[] args){
+      Matriz m1, m2, soma, m3, m4, multiplicao;
+
+      m1 = new Matriz(MyIO.readInt("Digite o numero de linhas (M1): "), MyIO.readInt("Digite o numero de colunas (M1): "));
+      m2 = new Matriz(MyIO.readInt("Digite o numero de linhas (M2): "), MyIO.readInt("Digite o numero de colunas (M2): "));
+      m3 = new Matriz(MyIO.readInt("Digite o numero de linhas (M3): "), MyIO.readInt("Digite o numero de colunas (M3): "));
+      m4 = new Matriz(MyIO.readInt("Digite o numero de linhas (M4): "), MyIO.readInt("Digite o numero de colunas (M4): "));
+
+
+      m1.ler();
+      m2.ler();
+      m3.ler();
+      m4.ler();
+
+      //Somar as duas matrizes e salvar o resultado na matriz soma
+      soma = m1.soma(m2); //verifique se eh possivel somar
+
+      //Imprimir a matriz 1
+      soma.print();
+
+      //Multiplicar duas matrizes e salvar o resultado na matriz multiplicacao
+      multiplicacao = m3.multiplicacao(m4); //verifique se eh possivel multiplicar
+
+      //Imprimir a matriz 1
+      multiplicacao.print();
+
+   }
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/matriz/entrada.in

@@ -0,0 +1,37 @@
+quantidade de testes (por exemplo, 3)
+linhas da primeira matriz do primeiro teste
+colunas da primeira matriz do primeiro teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da segunda matriz do primeiro teste
+colunas da segunda matriz do primeiro teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da primeira matriz do segundo teste
+colunas da primeira matriz do segundo teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da segunda matriz do segundo teste
+colunas da segunda matriz do segundo teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da primeira matriz do terceiro teste
+colunas da primeira matriz do terceiro teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x
+linhas da segunda matriz do terceiro teste
+colunas da segunda matriz do terceiro teste
+x x x x x ... x
+x x x x x ... x
+...
+x x x x x ... x

fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Celula.java

@@ -0,0 +1,26 @@
+/**
+ * Celula (pilha, lista e fila dinamica)
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+class Celula {
+	public int elemento; // Elemento inserido na celula.
+	public Celula prox; // Aponta a celula prox.
+
+
+	/**
+	 * Construtor da classe.
+	 */
+	public Celula() {
+		this(0);
+	}
+
+	/**
+	 * Construtor da classe.
+	 * @param elemento int inserido na celula.
+	 */
+	public Celula(int elemento) {
+      this.elemento = elemento;
+      this.prox = null;
+	}
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/Pilha.java

@@ -0,0 +1,90 @@
+/**
+ * Pilha dinamica
+ * 
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+public class Pilha {
+	private Celula topo;
+
+	/**
+	 * Construtor da classe que cria uma fila sem elementos.
+	 */
+	public Pilha() {
+		topo = null;
+	}
+
+	/**
+	 * Insere elemento na pilha (politica FILO).
+	 * 
+	 * @param x int elemento a inserir.
+	 */
+	public void inserir(int x) {
+		Celula tmp = new Celula(x);
+		tmp.prox = topo;
+		topo = tmp;
+		tmp = null;
+	}
+
+	/**
+	 * Remove elemento da pilha (politica FILO).
+	 * 
+	 * @return Elemento removido.
+	 * @trhows Exception Se a sequencia nao contiver elementos.
+	 */
+	public int remover() throws Exception {
+		if (topo == null) {
+			throw new Exception("Erro ao remover!");
+		}
+		int resp = topo.elemento;
+		Celula tmp = topo;
+		topo = topo.prox;
+		tmp.prox = null;
+		tmp = null;
+		return resp;
+	}
+
+	/**
+	 * Mostra os elementos separados por espacos, comecando do topo.
+	 */
+	public void mostrar() {
+		System.out.print("[ ");
+		for (Celula i = topo; i != null; i = i.prox) {
+			System.out.print(i.elemento + " ");
+		}
+		System.out.println("] ");
+	}
+
+	public int getSoma() {
+		return getSoma(topo);
+	}
+
+	private int getSoma(Celula i) {
+		int resp = 0;
+		if (i != null) {
+			resp += i.elemento + getSoma(i.prox);
+		}
+		return resp;
+	}
+
+	public int getMax() {
+		int max = topo.elemento;
+		for (Celula i = topo.prox; i != null; i = i.prox) {
+			if (i.elemento > max)
+				max = i.elemento;
+		}
+		return max;
+	}
+
+	public void mostraPilha() {
+		mostraPilha(topo);
+	}
+
+	private void mostraPilha(Celula i) {
+		if (i != null) {
+			mostraPilha(i.prox);
+			System.out.println("" + i.elemento);
+		}
+	}
+
+}

fonte/U5 - Estruturas de dados lineares e flexíveis/java/pilha/PrincipalPilha.java

@@ -0,0 +1,35 @@
+/**
+ * Pilha dinamica
+ * @author Max do Val Machado
+ * @version 2 01/2015
+ */
+public class PrincipalPilha {
+	public static void main(String[] args) {
+		try {
+			System.out.println(" ==== PILHA DINAMICA ====");
+			Pilha pilha = new Pilha();
+         int x1, x2, x3;
+
+			pilha.inserir(0);
+			pilha.inserir(1);
+			pilha.inserir(2);
+			pilha.inserir(3);
+			pilha.inserir(4);
+			pilha.inserir(5);
+
+			System.out.print("Apos insercoes: ");
+			pilha.mostrar();
+
+			x1 = pilha.remover();
+			x2 = pilha.remover();
+			x3 = pilha.remover();
+
+			System.out.print("Apos as remocoes (" + x1 + "," + x2 + "," + x3 + "): ");
+			pilha.mostrar();
+
+		}
+		catch(Exception erro) {
+			System.out.println(erro.getMessage());
+		}
+	}
+}

fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.c

@@ -0,0 +1,201 @@
+/**
+ * Arvore binaria de pesquisa
+ * @author Max do Val Machado
+ */
+#include <err.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "arvorebinaria.h"
+
+/*
+ * Variavel global
+ */
+No* raiz;
+
+/**
+ * Criar arvore binaria.
+ */
+void start() {
+   raiz = NULL;
+}
+
+/**
+ * Metodo publico iterativo para pesquisar elemento.
+ * @param x Elemento que sera procurado.
+ * @return <code>true</code> se o elemento existir,
+ * <code>false</code> em caso contrario.
+ */
+bool pesquisar(int x) {
+   return pesquisarRec(x, raiz);
+}
+
+/**
+ * Metodo privado recursivo para pesquisar elemento.
+ * @param x Elemento que sera procurado.
+ * @param i No em analise.
+ * @return <code>true</code> se o elemento existir,
+ * <code>false</code> em caso contrario.
+ */
+bool pesquisarRec(int x, No* i) {
+   bool resp;
+   if (i == NULL) {
+      resp = false;
+
+   } else if (x == i->elemento) {
+      resp = true;
+
+   } else if (x < i->elemento) {
+      resp = pesquisarRec(x, i->esq);
+
+   } else {
+      resp = pesquisarRec(x, i->dir);
+   }
+   return resp;
+}
+
+/**
+ * Metodo publico iterativo para exibir elementos.
+ */
+void caminharCentral() {
+   printf("[ ");
+   caminharCentralRec(raiz);
+   printf("]\n");
+}
+
+/**
+ * Metodo privado recursivo para exibir elementos.
+ * @param i No em analise.
+ */
+void caminharCentralRec(No* i) {
+   if (i != NULL) {
+      caminharCentralRec(i->esq);
+      printf("%d ", i->elemento);
+      caminharCentralRec(i->dir);
+   }
+}
+
+/**
+ * Metodo publico iterativo para exibir elementos.
+ */
+void caminharPre() {
+   printf("[ ");
+   caminharPreRec(raiz);
+   printf("]\n");
+}
+
+/**
+ * Metodo privado recursivo para exibir elementos.
+ * @param i No em analise.
+ */
+void caminharPreRec(No* i) {
+   if (i != NULL) {
+      printf("%d ", i->elemento);
+      caminharPreRec(i->esq);
+      caminharPreRec(i->dir);
+   }
+}
+
+/**
+ * Metodo publico iterativo para exibir elementos.
+ */
+void caminharPos() {
+   printf("[ ");
+   caminharPosRec(raiz);
+   printf("]\n");
+}
+
+/**
+ * Metodo privado recursivo para exibir elementos.
+ * @param i No em analise.
+ */
+void caminharPosRec(No* i) {
+   if (i != NULL) {
+      caminharPosRec(i->esq);
+      caminharPosRec(i->dir);
+      printf("%d ", i->elemento);
+   }
+}
+
+/**
+ * Metodo publico iterativo para inserir elemento.
+ * @param x Elemento a ser inserido.
+ */
+void inserir(int x) {
+   inserirRec(x, &raiz);
+}
+
+/**
+ * Metodo privado recursivo para inserir elemento.
+ * @param x Elemento a ser inserido.
+ * @param i No** endereco do ponteiro No
+ */
+void inserirRec(int x, No** i) {
+   if (*i == NULL) {
+      *i = novoNo(x);
+
+   } else if (x < (*i)->elemento) {
+      inserirRec(x, &((*i)->esq));
+
+   } else if (x > (*i)->elemento) {
+      inserirRec(x, &((*i)->dir));
+
+   } else {
+      errx(1, "Erro ao inserir!");
+   }
+}
+
+/**
+ * Metodo publico iterativo para remover elemento.
+ * @param x Elemento a ser removido.
+ */
+void remover(int x) {
+   removerRec(x, &raiz);
+}
+
+/**
+ * Metodo privado recursivo para remover elemento.
+ * @param x Elemento a ser removido.
+ * @param i No** endereco do ponteiro No
+ */
+void removerRec(int x, No** i) {
+   if (*i == NULL) {
+      errx(1, "Erro ao remover!");
+
+   } else if (x < (*i)->elemento) {
+      removerRec(x, &((*i)->esq));
+
+   } else if (x > (*i)->elemento) {
+      removerRec(x, &((*i)->dir));
+
+   } else if ((*i)->dir == NULL) {
+      No* del = *i;
+      *i = (*i)->esq;
+      free(del);
+
+   } else if ((*i)->esq == NULL) {
+      No* del = *i;
+      *i = (*i)->dir;
+      free(del);
+
+   } else {
+      antecessor(i, &((*i)->esq));
+   }
+}
+
+/**
+ * Metodo para trocar no removido pelo antecessor.
+ * @param i No** endereco do ponteiro No que contem o elemento removido.
+ * @param j No** endereco do ponteiro No da subarvore esquerda.
+ */
+void antecessor(No** i, No** j) {
+   if ((*j)->dir != NULL) {
+      antecessor(i, &((*j)->dir));
+
+   } else {
+      No* del = *j;
+      (*i)->elemento = (*j)->elemento;
+      (*j) = (*j)->esq;
+      free(del);
+   }
+}
+

fonte/U6 - Árvores binárias/c/arvoreBinariaC/arvorebinaria.h

@@ -0,0 +1,25 @@
+/**
+ * Arvore binaria de pesquisa
+ * @author Max do Val Machado
+ */
+
+#include "no.h"
+#define bool   short
+#define true   1
+#define false  0
+
+bool pesquisarRec(int, No*);
+void caminharCentralRec(No*);
+void caminharPreRec(No*);
+void caminharPosRec(No*);
+void inserirRec(int, No**);
+void removerRec(int, No**);
+void antecessor(No**, No**);
+
+void start();
+bool pesquisar(int);
+void caminharCentral();
+void caminharPre();
+void caminharPos();
+void inserir(int);
+void remover(int);

fonte/U6 - Árvores binárias/c/arvoreBinariaC/makefile

@@ -0,0 +1,19 @@
+all: exec
+ 
+exec: principal.o arvorebinaria.o no.o 
+	gcc -o exec principal.o arvorebinaria.o no.o
+ 
+principal.o: principal.c 
+	gcc -o principal.o principal.c -c -W -Wall -ansi -pedantic
+ 
+arvorebinaria.o: arvorebinaria.c 
+	gcc -o arvorebinaria.o arvorebinaria.c -c -W -Wall -ansi -pedantic
+ 
+no.o: no.c 
+	gcc -o no.o no.c -c -W -Wall -ansi -pedantic
+
+clean:
+	rm -rf *.o *~ exec
+
+limpa: 
+	rm -rf *.o  

fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.c

@@ -0,0 +1,18 @@
+/**
+ * No da arvore binaria
+ * @author Max do Val Machado
+ */
+#include <stdlib.h>
+#include "no.h"
+
+/**
+ * Criacao do novo no
+ * @param elemento Conteudo do no.
+ */
+No* novoNo(int elemento) {
+   No* novo = (No*) malloc(sizeof(No));
+   novo->elemento = elemento;
+   novo->esq = NULL;
+   novo->dir = NULL;
+   return novo;
+}

fonte/U6 - Árvores binárias/c/arvoreBinariaC/no.h

@@ -0,0 +1,15 @@
+/**
+ * No da arvore binaria
+ * @author Max do Val Machado
+ */
+
+typedef struct No {
+      int elemento;
+	struct No *esq, *dir;
+} No;
+
+/**
+ * Criacao do novo no
+ * @param elemento Conteudo do no.
+ */
+No* novoNo(int elemento);

fonte/U6 - Árvores binárias/c/arvoreBinariaC/principal.c

@@ -0,0 +1,60 @@
+/**
+ * Principal para Arvore Binaria de Pesquisa
+ * @author Max do Val Machado
+ */
+#include "arvorebinaria.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(){
+
+   start();
+
+   inserir(3);
+   inserir(5);
+   inserir(1);
+   inserir(8);
+   inserir(2);
+   inserir(4);
+   inserir(7);
+   inserir(6);
+
+   printf("\nInserir: 3, 5, 1, 8, 2, 4, 7 e 6");
+   printf("\nCaminhar: central, pre e pos\n");
+   caminharCentral();
+   caminharPre();
+   caminharPos();
+
+   printf("\nRemover: 2");
+   printf("\nCaminhar: central, pre e pos\n");
+   remover(2);
+
+   caminharCentral();
+   caminharPre();
+   caminharPos();
+
+   printf("\nVoltando com a árvore inicial");
+   printf("\nRemover: 1");
+   printf("\nCaminhar: central, pre e pos\n");
+   inserir(2);
+   remover(1);
+
+   caminharCentral();
+   caminharPre();
+   caminharPos();
+
+   printf("\nVoltando com a árvore inicial");
+   printf("\nRemover: 3");
+   printf("\nCaminhar: central, pre e pos\n");
+   remover(2);
+   inserir(1);
+   inserir(2);
+   remover(3);
+
+   caminharCentral();
+   caminharPre();
+   caminharPos();
+
+
+   return 1;
+}

fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.cc

@@ -0,0 +1,200 @@
+/**
+ * Arvore binaria de pesquisa
+ * @author Max do Val Machado
+ */
+
+#include <err.h>
+#include "arvorebinaria.h"
+
+/**
+ * Construtor da classe.
+ */
+ArvoreBinaria::ArvoreBinaria() {
+   raiz = NULL;
+}
+
+/**
+ * Metodo publico iterativo para pesquisar elemento.
+ * @param x Elemento que sera procurado.
+ * @return <code>true</code> se o elemento existir,
+ * <code>false</code> em caso contrario.
+ */
+bool ArvoreBinaria::pesquisar(int x) {
+   return pesquisar(x, raiz);
+}
+
+/**
+ * Metodo privado recursivo para pesquisar elemento.
+ * @param x Elemento que sera procurado.
+ * @param i No em analise.
+ * @return <code>true</code> se o elemento existir,
+ * <code>false</code> em caso contrario.
+ */
+bool ArvoreBinaria::pesquisar(int x, No* i) {
+   bool resp;
+   if (i == NULL) {
+      resp = false;
+
+   } else if (x == i->elemento) {
+      resp = true;
+
+   } else if (x < i->elemento) {
+      resp = pesquisar(x, i->esq);
+
+   } else {
+      resp = pesquisar(x, i->dir);
+   }
+   return resp;
+}
+
+/**
+ * Metodo publico iterativo para exibir elementos.
+ */
+void ArvoreBinaria::caminharCentral() {
+   cout << "[ ";
+   caminharCentral(raiz);
+   cout << "]\n";
+}
+
+/**
+ * Metodo privado recursivo para exibir elementos.
+ * @param i No em analise.
+ */
+void ArvoreBinaria::caminharCentral(No* i) {
+   if (i != NULL) {
+      caminharCentral(i->esq); // Elementos da esquerda.
+      cout << i->elemento << " "; // Conteudo do no.
+      caminharCentral(i->dir); // Elementos da direita.
+   }
+}
+
+/**
+ * Metodo publico iterativo para exibir elementos.
+ */
+void ArvoreBinaria::caminharPre() {
+   cout << "[ ";
+   caminharPre(raiz);
+   cout << "]\n";
+}
+
+/**
+ * Metodo privado recursivo para exibir elementos.
+ * @param i No em analise.
+ */
+void ArvoreBinaria::caminharPre(No* i) {
+   if (i != NULL) {
+      cout << i->elemento << " "; // Conteudo do no.
+      caminharPre(i->esq); // Elementos da esquerda.
+      caminharPre(i->dir); // Elementos da direita.
+   }
+}
+
+/**
+ * Metodo publico iterativo para exibir elementos.
+ */
+void ArvoreBinaria::caminharPos() {
+   cout << "[ ";
+   caminharPos(raiz);
+   cout << "]\n";
+}
+
+/**
+ * Metodo privado recursivo para exibir elementos.
+ * @param i No em analise.
+ */
+void ArvoreBinaria::caminharPos(No* i) {
+   if (i != NULL) {
+      caminharPos(i->esq); // Elementos da esquerda.
+      caminharPos(i->dir); // Elementos da direita.
+      cout << i->elemento << " "; // Conteudo do no.
+   }
+}
+
+/**
+ * Metodo publico iterativo para inserir elemento.
+ * @param x Elemento a ser inserido.
+ */
+void ArvoreBinaria::inserir(int x) {
+   inserir(x, raiz);
+}
+
+/**
+ * Metodo privado recursivo para inserir elemento.
+ * @param x Elemento a ser inserido.
+ * @param i No em analise.
+ */
+void ArvoreBinaria::inserir(int x, No* &i) {
+   if (i == NULL) {
+      i = new No(x);
+
+   } else if (x < i->elemento) {
+      inserir(x, i->esq);
+
+   } else if (x > i->elemento) {
+         inserir(x, i->dir);
+
+   } else {
+         errx(1, "Erro ao inserir!");
+   }
+}
+
+   /**
+    * Metodo publico iterativo para remover elemento.
+    * @param x Elemento a ser removido.
+ */
+void ArvoreBinaria::remover(int x) {
+   remover(x, raiz);
+}
+
+/**
+ * Metodo privado recursivo para remover elemento.
+ * @param x Elemento a ser removido.
+ * @param i No em analise.
+ */
+void ArvoreBinaria::remover(int x, No* &i) {
+   if (i == NULL) {
+      errx(1, "Erro ao remover!");
+
+   } else if (x < i->elemento) {
+      remover(x, i->esq);
+
+   } else if (x > i->elemento) {
+      remover(x, i->dir);
+
+      // Sem no a direita.
+   } else if (i->dir == NULL) {
+      No* del = i;
+      i = i->esq;
+      delete del;
+
+      // Sem no a esquerda.
+   } else if (i->esq == NULL) {
+      No* del = i;
+      i = i->dir;
+      delete del;
+
+      // No a esquerda e no a direita.
+   } else {
+      antecessor(i, i->esq);
+   }
+}
+
+
+/**
+ * Metodo para trocar no removido pelo antecessor.
+ * @param i No que teve o elemento removido.
+ * @param j No da subarvore esquerda.
+ */
+void ArvoreBinaria::antecessor(No* i, No* &j) {
+   // Existe no a direita.
+   if (j->dir != NULL) {
+      antecessor(i, j->dir); // Caminha para direita.
+
+      // Encontrou o maximo da subarvore esquerda.
+   } else {
+      No* del = j;
+      i->elemento = j->elemento; // Substitui i por j.
+      j = j->esq; // Substitui j por j.ESQ.
+      delete del;
+   }
+}

fonte/U6 - Árvores binárias/c/arvoreBinariaCC/arvorebinaria.h

@@ -0,0 +1,27 @@
+/**
+ * Arvore binaria de pesquisa
+ * @author Max do Val Machado
+ */
+
+#include "no.h"
+
+class ArvoreBinaria {
+   private:
+      No* raiz; // Raiz da arvore.
+	   bool pesquisar(int, No*);
+	   void caminharCentral(No*);
+	   void caminharPre(No*);
+	   void caminharPos(No*);
+	   void inserir(int, No* &);
+	   void remover(int, No* &);
+	   void antecessor(No*, No* &);
+
+   public:
+      ArvoreBinaria();
+	   bool pesquisar(int);
+	   void caminharCentral();
+	   void caminharPre();
+	   void caminharPos();
+	   void inserir(int);
+	   void remover(int);
+};

fonte/U6 - Árvores binárias/c/arvoreBinariaCC/makefile

@@ -0,0 +1,16 @@
+all: exec
+ 
+exec: principal.o arvorebinaria.o no.o 
+	g++ -o exec principal.o arvorebinaria.o no.o
+ 
+principal.o: principal.cc arvorebinaria.h no.h
+	g++ -o principal.o principal.cc -c -W -Wall -ansi -pedantic
+ 
+arvorebinaria.o: arvorebinaria.cc arvorebinaria.h no.h
+	g++ -o arvorebinaria.o arvorebinaria.cc -c -W -Wall -ansi -pedantic
+ 
+no.o: no.cc no.h
+	g++ -o no.o no.cc -c -W -Wall -ansi -pedantic
+
+clean:
+	rm -rf *.o *~ exec

fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.cc

@@ -0,0 +1,16 @@
+/**
+ * No da arvore binaria
+ * @author Max do Val Machado
+ */
+
+#include "no.h"
+
+/**
+ * Construtor da classe.
+ * @param elemento Conteudo do no.
+ */
+No::No(int elemento) {
+   this->elemento = elemento;
+   this->esq = NULL;
+   this->dir = NULL;
+}

fonte/U6 - Árvores binárias/c/arvoreBinariaCC/no.h

@@ -0,0 +1,14 @@
+/**
+ * No da arvore binaria
+ * @author Max do Val Machado
+ */
+#include <iostream>
+
+using namespace std;
+
+class No {
+   public:
+      int elemento; // Conteudo do no.
+	   No *esq, *dir;  // Filhos da esq e dir.
+      No(int);
+};

fonte/U6 - Árvores binárias/c/arvoreBinariaCC/principal.cc

@@ -0,0 +1,60 @@
+/**
+ * Principal para Arvore Binaria de Pesquisa
+ * @author Max do Val Machado
+ */
+#include "arvorebinaria.h"
+#include <iostream>
+using namespace std;
+
+int main(){//int argc, char** argv){
+   ArvoreBinaria* arvoreBinaria = new ArvoreBinaria();
+
+   arvoreBinaria->inserir(3);
+   arvoreBinaria->inserir(5);
+   arvoreBinaria->inserir(1);
+   arvoreBinaria->inserir(8);
+   arvoreBinaria->inserir(2);
+   arvoreBinaria->inserir(4);
+   arvoreBinaria->inserir(7);
+   arvoreBinaria->inserir(6);
+
+   cout << "\nInserir: 3, 5, 1, 8, 2, 4, 7 e 6";
+   cout << "\nCaminhar: central, pre e pos\n";
+   arvoreBinaria->caminharCentral();
+   arvoreBinaria->caminharPre();
+   arvoreBinaria->caminharPos();
+
+
+   cout << "\nRemover: 2";
+   cout << "\nCaminhar: central, pre e pos\n";
+   arvoreBinaria->remover(2);
+
+   arvoreBinaria->caminharCentral();
+   arvoreBinaria->caminharPre();
+   arvoreBinaria->caminharPos();
+
+   cout << "\nVoltando com a árvore inicial";
+   cout << "\nRemover: 1";
+   cout << "\nCaminhar: central, pre e pos\n";
+   arvoreBinaria->inserir(2);
+   arvoreBinaria->remover(1);
+
+   arvoreBinaria->caminharCentral();
+   arvoreBinaria->caminharPre();
+   arvoreBinaria->caminharPos();
+
+   cout << "\nVoltando com a árvore inicial";
+   cout << "\nRemover: 3";
+   cout << "\nCaminhar: central, pre e pos\n";
+   arvoreBinaria->remover(2);
+   arvoreBinaria->inserir(1);
+   arvoreBinaria->inserir(2);
+   arvoreBinaria->remover(3);
+
+   arvoreBinaria->caminharCentral();
+   arvoreBinaria->caminharPre();
+   arvoreBinaria->caminharPos();
+
+
+   return 1;
+}

fonte/U6 - Árvores binárias/java/arvoreArvore/ArvoreArvore.java

@@ -0,0 +1,67 @@
+/**
+ * Arvore de arvore
+ * @author Max do Val Machado
+ */
+public class ArvoreArvore {
+	private No raiz; // Raiz da arvore.
+
+	/**
+	 * Construtor da classe.
+	 */
+	public ArvoreArvore() {
+		raiz = null;
+      inserir('M');
+      inserir('T');
+      inserir('F');
+      //os outros 23 caracteres.
+	}
+
+	/**
+	 * Metodo publico iterativo para pesquisar elemento.
+	 * @param elemento Elemento que sera procurado.
+	 * @return <code>true</code> se o elemento existir,
+	 * <code>false</code> em caso contrario.
+	 */
+	public boolean pesquisar(String elemento) {
+		return pesquisar(raiz, elemento);
+	}
+
+	private boolean pesquisar(No no, String x) {
+      boolean resp;
+		if (no == null) { 
+         resp = false;
+
+      } else if (x.charAt(0) == no.elemento) { 
+         resp = pesquisarSegundaArvore(no.outro, x); 
+
+      } else if (x.charAt(0) < no.elemento) { 
+         resp = pesquisar(no.esq, x); 
+
+      } else { 
+         resp = pesquisar(no.dir, x); 
+      }
+      return resp;
+	}
+
+	private boolean pesquisarSegundaArvore(No2 no, String x) {
+      boolean resp;
+		if (no == null) { 
+         resp = false;
+
+      } else if (x.equals(no.elemento)) { 
+         resp = true; 
+
+      } else if (x.compareTo(no.elemento) < 0) { 
+         resp = pesquisarSegundaArvore(no.esq, x); 
+
+      } else { 
+         resp = pesquisarSegundaArvore(no.dir, x); 
+      }
+      return resp;
+	}
+
+   private void inserir(char c){
+      System.out.println(c);
+      //implementar
+   }
+}

fonte/U6 - Árvores binárias/java/arvoreArvore/No.java

@@ -0,0 +1,35 @@
+class No {
+	public char elemento; // Conteudo do no.
+	public No esq; // No da esquerda.
+	public No dir; // No da direita.
+   public No2 outro;
+	
+   /**
+	 * Construtor da classe.
+	 * @param elemento Conteudo do no.
+	 */
+	No(char elemento) {
+		this.elemento = elemento;
+		this.esq = this.dir = null;
+      this.outro = null;
+	}
+
+	/**
+	 * Construtor da classe.
+	 * @param elemento Conteudo do no.
+	 * @param esq No da esquerda.
+	 * @param dir No da direita.
+	 */
+	No(char elemento, No esq, No dir) {
+		this.elemento = elemento;
+		this.esq = esq;
+		this.dir = dir;
+      this.outro = null;
+	}
+}
+
+
+
+
+
+

fonte/U6 - Árvores binárias/java/arvoreArvore/No2.java

@@ -0,0 +1,26 @@
+class No2 {
+	public String elemento; // Conteudo do no.
+	public No2 esq; // No da esquerda.
+	public No2 dir; // No da direita.
+	
+   /**
+	 * Construtor da classe.
+	 * @param elemento Conteudo do no.
+	 */
+	No2(String elemento) {
+		this.elemento = elemento;
+		this.esq = this.dir = null;
+	}
+
+	/**
+	 * Construtor da classe.
+	 * @param elemento Conteudo do no.
+	 * @param esq No2 da esquerda.
+	 * @param dir No2 da direita.
+	 */
+	No2(String elemento, No2 esq, No2 dir) {
+		this.elemento = elemento;
+		this.esq = esq;
+		this.dir = dir;
+	}
+}

fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Agenda.java

@@ -0,0 +1,98 @@
+public class Agenda {
+	private No raiz; 
+
+	public Agenda() {
+		/*raiz = new No ('M');
+		raiz.esq = new No ('F');
+		raiz.dir = new No ('T');
+		raiz.esq.esq = new No ('C');*/
+		raiz = null;
+		//inserir todas as 26 letras do alfabeto...
+	}
+
+	public boolean pesquisarNome(String nome) {
+		return pesquisarNome(raiz, nome);
+	}
+
+	private boolean pesquisarNome(No no, String nome) {
+      boolean resp;
+		if (no == null) { 
+         resp = false;
+      } else if (Char.toUpper(nome.charAt(0)) == no.letra) { 
+         resp = false;
+         for(Celula i = no.primeiro.prox; (!resp && i != null); i = i.prox){
+            if(i.contato.nome.equals(nome) == true){
+               resp = true;
+            }
+         }
+      } else if (Char.toUpper(nome.charAt(0)) < no.letra) { 
+         resp = pesquisarNome(no.esq, nome); 
+
+      } else { 
+         resp = pesquisarNome(no.dir, nome); 
+      }
+      return resp;
+	}
+
+	public void inserir(Contato contato) throws Exception {
+		if(Character.isLetter(contato.nome.charAt(0))){
+			raiz = inserir(raiz, contato);	
+		} else {
+			throw new Exception("Erro ao inserir!");
+		}
+	}
+
+	private No inserir(No no, Contato contato) throws Exception {
+		// insere o nó com a letra
+		if (no == null) {
+			no = new no(Character.toUpperCase(contato.nome.charAt(0)));
+			no.primeiro = no.ultimo = new Celula();
+			no.ultimo.prox = new Celula(contato);
+			no.ultimo = no.ultimo.prox;	
+		
+		// insere o contatinho
+		} else if (Character.toUpperCase(contato.nome.charAt(0)) == no.letra) { 
+			no.ultimo.prox = new Celula(contato);
+			no.ultimo = no.ultimo.prox;
+		
+		// letra menor, caminha para a esquerda
+		} else if (Character.toUpperCase(contato.nome.charAt(0)) < no.letra) { 
+			no.esq = inserir(no.esq, contato);
+
+		// letra maior, caminha para a direita
+		} else { 
+			no.dir = inserir(no.dir, contato);
+		}
+		return no;
+	}
+	
+	public boolean pesquisar(int cpf) {
+		return pesquisar(raiz, cpf);
+	}
+
+	private boolean pesquisar(No i, int cpf) {
+		boolean resp = false;
+		if (i != null) {
+			resp = pesquisar(i.primeiro.prox, cpf);
+			if(resp == false){
+				resp = pesquisar(i.esq, cpf);
+				if(resp == false){
+					resp = pesquisar(i.dir, cpf);
+				}
+			}
+		}
+		return resp;
+	}
+
+	private boolean pesquisar(Celula i, int cpf){
+		//efeuar a pesquisa na lista a partir do i
+	}
+
+}
+
+
+
+
+
+
+

fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Celula.java

@@ -0,0 +1,18 @@
+class Celula {
+   Contato contato;
+   Celula prox;
+
+   public Celula (){
+      this.contato = null;
+      this.prox = null;
+   }
+
+   public Celula (Contato contato, Celula prox){
+      this.contato = contato;
+      this.prox = prox;
+   }
+
+   public Celula(Contato contato){
+      this(contato, null);
+   }
+}

fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/Contato.java

@@ -0,0 +1,6 @@
+class Contato {
+   public String nome;
+   public String telefone;
+   public String email;
+   public int cpf;
+}

fonte/U6 - Árvores binárias/java/arvoreBinariaDeLista/No.java

@@ -0,0 +1,12 @@
+
+class No {
+	public Celula primeiro, ultimo;
+	public No esq, dir;
+	public char letra;
+	
+	No(char letra) {
+		this.letra = letra;
+		this.esq = this.dir = null;
+		primeiro = ultimo = new Celula();
+	}
+}

fonte/U6 - Árvores binárias/java/arvoreBinariaJava/ArvoreBinaria.java

@@ -0,0 +1,350 @@
+/**
+ * Arvore binaria de pesquisa
+ * @author Max do Val Machado
+ */
+public class ArvoreBinaria {
+	private No raiz; // Raiz da arvore.
+
+	/**
+	 * Construtor da classe.
+	 */
+	public ArvoreBinaria() {
+		raiz = null;
+	}
+
+	/**
+	 * Metodo publico iterativo para pesquisar elemento.
+	 * @param x Elemento que sera procurado.
+	 * @return <code>true</code> se o elemento existir,
+	 * <code>false</code> em caso contrario.
+	 */
+	public boolean pesquisar(int x) {
+		return pesquisar(x, raiz);
+	}
+
+	/**
+	 * Metodo privado recursivo para pesquisar elemento.
+	 * @param x Elemento que sera procurado.
+	 * @param i No em analise.
+	 * @return <code>true</code> se o elemento existir,
+	 * <code>false</code> em caso contrario.
+	 */
+	private boolean pesquisar(int x, No i) {
+      boolean resp;
+		if (i == null) {
+         resp = false;
+
+      } else if (x == i.elemento) {
+         resp = true;
+
+      } else if (x < i.elemento) {
+         resp = pesquisar(x, i.esq);
+
+      } else {
+         resp = pesquisar(x, i.dir);
+      }
+      return resp;
+	}
+
+	/**
+	 * Metodo publico iterativo para exibir elementos.
+	 */
+	public void caminharCentral() {
+		System.out.print("[ ");
+		caminharCentral(raiz);
+		System.out.println("]");
+	}
+
+	/**
+	 * Metodo privado recursivo para exibir elementos.
+	 * @param i No em analise.
+	 */
+	private void caminharCentral(No i) {
+		if (i != null) {
+			caminharCentral(i.esq); // Elementos da esquerda.
+			System.out.print(i.elemento + " "); // Conteudo do no.
+			caminharCentral(i.dir); // Elementos da direita.
+		}
+	}
+
+	/**
+	 * Metodo publico iterativo para exibir elementos.
+	 */
+	public void caminharPre() {
+		System.out.print("[ ");
+		caminharPre(raiz);
+		System.out.println("]");
+	}
+
+	/**
+	 * Metodo privado recursivo para exibir elementos.
+	 * @param i No em analise.
+	 */
+	private void caminharPre(No i) {
+		if (i != null) {
+			System.out.print(i.elemento + " "); // Conteudo do no.
+			caminharPre(i.esq); // Elementos da esquerda.
+			caminharPre(i.dir); // Elementos da direita.
+		}
+	}
+
+	/**
+	 * Metodo publico iterativo para exibir elementos.
+	 */
+	public void caminharPos() {
+		System.out.print("[ ");
+		caminharPos(raiz);
+		System.out.println("]");
+	}
+
+	/**
+	 * Metodo privado recursivo para exibir elementos.
+	 * @param i No em analise.
+	 */
+	private void caminharPos(No i) {
+		if (i != null) {
+			caminharPos(i.esq); // Elementos da esquerda.
+			caminharPos(i.dir); // Elementos da direita.
+			System.out.print(i.elemento + " "); // Conteudo do no.
+		}
+	}
+
+
+	/**
+	 * Metodo publico iterativo para inserir elemento.
+	 * @param x Elemento a ser inserido.
+	 * @throws Exception Se o elemento existir.
+	 */
+	public void inserir(int x) throws Exception {
+		raiz = inserir(x, raiz);
+	}
+
+	/**
+	 * Metodo privado recursivo para inserir elemento.
+	 * @param x Elemento a ser inserido.
+	 * @param i No em analise.
+	 * @return No em analise, alterado ou nao.
+	 * @throws Exception Se o elemento existir.
+	 */
+	private No inserir(int x, No i) throws Exception {
+		if (i == null) {
+         i = new No(x);
+
+      } else if (x < i.elemento) {
+         i.esq = inserir(x, i.esq);
+
+      } else if (x > i.elemento) {
+         i.dir = inserir(x, i.dir);
+
+      } else {
+         throw new Exception("Erro ao inserir!");
+      }
+
+		return i;
+	}
+
+	/**
+	 * Metodo publico para inserir elemento.
+	 * @param x Elemento a ser inserido.
+	 * @throws Exception Se o elemento existir.
+	 */
+	public void inserirPai(int x) throws Exception {
+      if(raiz == null){
+         raiz = new No(x);
+      } else if(x < raiz.elemento){
+		   inserirPai(x, raiz.esq, raiz);
+      } else if(x > raiz.elemento){
+		   inserirPai(x, raiz.dir, raiz);
+      } else {
+         throw new Exception("Erro ao inserirPai!");
+      }
+	}
+
+	/**
+	 * Metodo privado recursivo para inserirPai elemento.
+	 * @param x Elemento a ser inserido.
+	 * @param i No em analise.
+	 * @param pai No superior ao em analise.
+	 * @throws Exception Se o elemento existir.
+	 */
+	private void inserirPai(int x, No i, No pai) throws Exception {
+		if (i == null) {
+         if(x < i.elemento){
+            pai.esq = new No(x);
+         } else {
+            pai.dir = new No(x);
+         }
+      } else if (x < i.elemento) {
+         inserirPai(x, i.esq, i);
+      } else if (x > i.elemento) {
+         inserirPai(x, i.dir, i);
+      } else {
+         throw new Exception("Erro ao inserirPai!");
+      }
+	}
+
+
+	/**
+	 * Metodo publico iterativo para remover elemento.
+	 * @param x Elemento a ser removido.
+	 * @throws Exception Se nao encontrar elemento.
+	 */
+	public void remover(int x) throws Exception {
+		raiz = remover(x, raiz);
+	}
+
+	/**
+	 * Metodo privado recursivo para remover elemento.
+	 * @param x Elemento a ser removido.
+	 * @param i No em analise.
+	 * @return No em analise, alterado ou nao.
+	 * @throws Exception Se nao encontrar elemento.
+	 */
+	private No remover(int x, No i) throws Exception {
+
+		if (i == null) {
+         throw new Exception("Erro ao remover!");
+
+      } else if (x < i.elemento) {
+         i.esq = remover(x, i.esq);
+
+      } else if (x > i.elemento) {
+         i.dir = remover(x, i.dir);
+
+      // Sem no a direita.
+      } else if (i.dir == null) {
+         i = i.esq;
+
+      // Sem no a esquerda.
+      } else if (i.esq == null) {
+         i = i.dir;
+
+      // No a esquerda e no a direita.
+      } else {
+         i.esq = antecessor(i, i.esq);
+		}
+
+		return i;
+	}
+
+	/**
+	 * Metodo para trocar no removido pelo antecessor.
+	 * @param i No que teve o elemento removido.
+	 * @param j No da subarvore esquerda.
+	 * @return No em analise, alterado ou nao.
+	 */
+	private No antecessor(No i, No j) {
+
+      // Existe no a direita.
+		if (j.dir != null) {
+         // Caminha para direita.
+			j.dir = antecessor(i, j.dir);
+
+      // Encontrou o maximo da subarvore esquerda.
+		} else {
+			i.elemento = j.elemento; // Substitui i por j.
+			j = j.esq; // Substitui j por j.ESQ.
+		}
+		return j;
+	}
+
+	/**
+	 * Metodo publico iterativo para remover elemento.
+	 * @param x Elemento a ser removido.
+	 * @throws Exception Se nao encontrar elemento.
+	 */
+	public void remover2(int x) throws Exception {
+      if (raiz == null) {
+         throw new Exception("Erro ao remover2!");
+      } else if(x < raiz.elemento){
+         remover2(x, raiz.esq, raiz);
+      } else if (x > raiz.elemento){
+         remover2(x, raiz.dir, raiz);
+      } else if (raiz.dir == null) {
+         raiz = raiz.esq;
+      } else if (raiz.esq == null) {
+         raiz = raiz.dir;
+      } else {
+         raiz.esq = antecessor(raiz, raiz.esq);
+      }
+   }
+
+	/**
+	 * Metodo privado recursivo para remover elemento.
+	 * @param x Elemento a ser removido.
+	 * @param i No em analise.
+	 * @param pai do No em analise.
+	 * @throws Exception Se nao encontrar elemento.
+	 */
+	private void remover2(int x, No i, No pai) throws Exception {
+		if (i == null) {
+         throw new Exception("Erro ao remover2!");
+      } else if (x < i.elemento) {
+         remover2(x, i.esq, i);
+      } else if (x > i.elemento) {
+         remover2(x, i.dir, i);
+      } else if (i.dir == null) {
+         pai = i.esq;
+      } else if (i.esq == null) {
+         pai = i.dir;
+      } else {
+         i.esq = antecessor(i, i.esq);
+		}
+	}
+
+   public int getRaiz() throws Exception {
+      return raiz.elemento;
+   }
+
+   public static boolean igual (ArvoreBinaria a1, ArvoreBinaria a2){
+      return igual(a1.raiz, a2.raiz);
+   }
+
+   private static boolean igual (No i1, No i2){
+      boolean resp;
+      if(i1 != null && i2 != null){
+         resp = (i1.elemento == i2.elemento) && igual(i1.esq, i2.esq) && igual(i1.dir, i2.dir);
+      } else if(i1 == null && i2 == null){
+         resp = true;
+      } else {
+         resp = false; 
+      }
+      return resp;
+   }
+
+   public int soma(){
+      return soma(raiz);
+   }
+
+   public int soma(No i){
+      int resp = 0;
+      if(i != null){
+         resp = i.elemento + soma(i.esq) + soma(i.dir);
+      }
+      return resp;
+   }
+
+   public int quantidadePares(){
+      return quantidadePares(raiz);
+   }
+
+   public int quantidadePares(No i){
+      int resp = 0;
+      if(i != null){
+         resp = ((i.elemento % 2 == 0) ? 1 : 0) + quantidadePares(i.esq) + quantidadePares(i.dir);
+      }
+      return resp;
+   }
+
+   public boolean hasDiv11(){
+      return hasDiv11(raiz);
+   }
+
+   public boolean hasDiv11(No i){
+      boolean resp = false;
+      if(i != null){
+         resp = (i.elemento % 11 == 0) || hasDiv11(i.esq) || hasDiv11(i.dir);
+      }
+      return resp;
+   }
+}

fonte/U6 - Árvores binárias/java/arvoreBinariaJava/No.java

@@ -0,0 +1,28 @@
+/**
+ * No da arvore binaria
+ * @author Max do Val Machado
+ */
+class No {
+	public int elemento; // Conteudo do no.
+	public No esq, dir;  // Filhos da esq e dir.
+
+	/**
+	 * Construtor da classe.
+	 * @param elemento Conteudo do no.
+	 */
+	public No(int elemento) {
+		this(elemento, null, null);
+	}
+
+	/**
+	 * Construtor da classe.
+	 * @param elemento Conteudo do no.
+	 * @param esq No da esquerda.
+	 * @param dir No da direita.
+	 */
+	public No(int elemento, No esq, No dir) {
+		this.elemento = elemento;
+		this.esq = esq;
+		this.dir = dir;
+	}
+}

fonte/U6 - Árvores binárias/java/arvoreBinariaJava/Principal.java

@@ -0,0 +1,30 @@
+/**
+ * Principal para Arvore Binaria de Pesquisa
+ * @author Max do Val Machado
+ */
+public class Principal {
+   public static void main(String[] args) throws Exception {
+      ArvoreBinaria arvoreBinaria = new ArvoreBinaria();
+
+      arvoreBinaria.inserir(3);
+      arvoreBinaria.inserir(5);
+      arvoreBinaria.inserir(1);
+      arvoreBinaria.inserir(8);
+      arvoreBinaria.inserir(2);
+      arvoreBinaria.inserir(4);
+      arvoreBinaria.inserir(7);
+      arvoreBinaria.inserir(6);
+
+      arvoreBinaria.caminharCentral();
+      arvoreBinaria.caminharPre();
+      arvoreBinaria.caminharPos();
+
+      arvoreBinaria.remover(6);
+      arvoreBinaria.remover(2);
+      arvoreBinaria.remover(4);
+
+      arvoreBinaria.caminharCentral();
+      arvoreBinaria.caminharPre();
+      arvoreBinaria.caminharPos();
+   }
+}