Indice dos exemplos e estrutura de dados

1. Arquivos - Criação Básica
2. Arquivos - Leitura Básica
3. Jogo adivinha número
4. Funcões para o jogo
5. Pilha
6. Fila
7. Lista
8. Ordena por partição

Exemplo de criação básica de arquivo em java

import java.io.*;
public class Arq1{
 public static void main(String args[])throws IOException{
 
 //Declarando um arquivo para a gravação dos dados
  FileWriter ArqAgenda;
 //Instânciando ArqAgenda e criando o arquivo agenda.txt
  ArqAgenda = new FileWriter("Agenda.txt");
 //Gravando os dados no arquivo.
  ArqAgenda.write("Meus dados gravados");
 //Fechando o arquivo criado
  ArqAgenda.close();

 System.exit(0);
 }
} 














Início



Exemplo de criação básica de leitura de arquivo em java

import java.io.*;
public class Leitura{
 public static void main(String args[])throws IOException{
 // Criando uma variável de Entrada
  String campo;
 
 // Criando um objeto do tipo arquivo (Leitura).
  FileReader ArqAgenda;
  
 //Instanciando o objeto.
  ArqAgenda  = new FileReader("Agenda.txt");

 // Cria um Buffer para a leitura do dado de entrada
 // na memória da máquina.
  BufferedReader BArqAgenda = new BufferedReader(ArqAgenda);

 // Carregando os dados para a memória.
  campo = BArqAgenda.readLine();

 // Fechando o arquivo aberto.
  ArqAgenda.close();

 //Mostrando o dado carregado em memória.
  System.out.println(""); 
  System.out.println("...........................................");
  System.out.println("Conteudo que esta em memoria");
  System.out.println("    "+ campo);
  System.out.println("...........................................");

 System.exit(0);
 }
} 
  














Início



Exemplo do jogo em java
class Jogo{
 //Variáveis publicas do programa
 public static int  jogadas = 0;
 public static  int jogada[] = new int[100];

 public static void main(String args[]){
   //int op = 0;
   int nescolhido = 0;
   int njogo = 0;

   Funcoes.lt();
   Funcoes.l("Entre com um numero ....");
   nescolhido = Keyboard.readInt();
   Funcoes.lt();
 

   while( nescolhido != njogo ){

    Funcoes.lt();
    Funcoes.l("Acerte o numero escolhido.");
    Funcoes.l(jogadas," rodada de 100");
    Funcoes.l("Entre com um numero");
    njogo = Keyboard.readInt();
    Funcoes.lt();

   if(njogo == nescolhido ){
      Funcoes.l("Acertou o numero");
   }
   else{
           if(njogo < nescolhido){
              Funcoes.l("O numero jogado e menor que o escolhido");
           }
           else{
             Funcoes.l("O numero jogado e maior que o escolhido");
           }
     } // Fim do escopo de decisões.
  
   Funcoes.pausa();

   //acumulo no vetor de jogada[].
   jogada[jogadas] = njogo;
   
   //Incremento de jogadas
    jogadas++;       
      

  }//Fim do laço Fim Enquanto.

   apresentacao();

 }//Fim do método principal



public static void apresentacao(){
  Funcoes.l("Voce teve ",jogadas);
  Funcoes.la(jogada);
  Funcoes.ordena(jogada);

}//Fim do modulo apresentacao
Início






- Biblioteca contendo as funções do programa.
class Funcoes{
//Módulo de escrita em tela.
  public static void l(String x){
        System.out.println(x);
  } 
//Sobrecarga de modulos.
 public static void l(int x,String y){
          System.out.println((x+1) + y);
    } 
 public static void l(String  x,int y){
          System.out.println(x + (y + 1) );
    } 
 public static void l(int y){
          System.out.println(y);
    }
//FIM DA SOBRECARGA DE MODULOS
//MODULO DE SAIDA NAO ORDENADA DE DADOS EM TELA. 
 public static void la(int x[]){
          l("Numeros jogados");
         for(int n=0;n <= 99; n++)
           if(x[n] != 0)
             l(x[n]);
        pausa();
    } 
//FIM DO MODULO DE SAIDA NAO ORDENADA EM TELA.
 public static void ordena(int x[]){
  int a,b,troca;
  a = 0;
  b = 1;
  troca = 0;

  while(a < 8){
     while(b < 9){
       if(x[a] > x[b]){
         troca = x[a];
         x[a]  = x[b];
         x[b]  = troca;
       }
      b++;
     }
   a++;
   b = a + 1;
  }
  l("Numeros de jogadas ordenados");
  la(x);
 }
//FIM DO MODULO DE ORDENACAO
//MODULO DE PAUSA EM TELA.
 public static void pausa(){
   String op = "";
   l("Aperte S ou s  + Enter para continuar ....");
   op = Keyboard.readString();
 }
//FIM DO MODULO PAUSA.
//Módulo de limpeza de tela.
  public static void lt(){

    for(int i = 0; i <= 54 ; i++)
      l("");
  }
//FIM DO MODULO DE LIMPEZA.
}

Início



Estruturas de Pilhas em Java.
As pilhas são estruturas baseadas no princípio FILO (first in,last out),
na qual os dados que foram inseridos
primeiros na pilha serão os últimos a
serem removidos.Existem duasfunções que se aplicam a todas as pilhas:

  PUSH,que insere um dado no topo da pilha.
  POP,que remove o item no topo da pilha.
  TOP, mostra o item no topo da pilha.

 


 Programa exemplo de pilha implementado em Java

class Pilha{
	public static double vetor[] = new double[15];
	public static int Topo = 0;
	public static void main(String args[]){
		int op = 0;
		
		while(op != 5){
			op = menu();
			switch(op){
				case 1:empilhar();break;
				case 2:desempilhar();break;
				case 3:mostarTopo();break;
				case 4:mostrarPilha();break;
				case 5:sair();break;
				default:System.out.println("Valor digitador errado !!!");
			}
		}
	}
	
	public static int menu(){
		int k =0;
		System.out.println("....................................");
		System.out.println(".  M E N U    D O   S I S T E M A  .");
		System.out.println(".                                  .");
		System.out.println(". 1. Empilhar                      .");
		System.out.println(". 2. Desempilhar                   .");   
		System.out.println(". 3. Mostrar topo                  .");
		System.out.println(". 4. Mostrar pilha                 .");
		System.out.println(". 5. Sair do sistema               .");
		System.out.println(".                                  .");
		System.out.println("....................................");
        System.out.print("Opcao : ");
        k=Keyboard.readInt();
        System.out.println("....................................");
        return k;
    }
    
    public static int vazia(){
    	Topo=contavetor();
    	if(Topo == 0)
    	 return 0;
    	else
    	 return 1;
    }
   
   public static int cheia(){
   		Topo=contavetor();
   		if(Topo >= 10)
   		 return 0;
   		else
   		 return 1;
   	}
   	
  	public static int contavetor(){
     int     tamanho;
     double  valor;
     tamanho = 0;
     valor   = 0;
  	 for(int contador = 1;contador <= 10;contador++){
	    valor = vetor[contador];
	    if(valor != 0)
	     tamanho++;
	 }       
     return tamanho;	
   }
   
   public static void empilhar(){
	if(cheia() != 0){
	   Topo++;
	   System.out.print("");
	   System.out.println(".....................................");
	   System.out.println(" Numero do elemento da pilha "+Topo);
	   System.out.println(" Entre com um valor para empilhar-mos");
	   vetor[Topo]=Keyboard.readDouble();
	   System.out.println(".....................................");
	}
	else{
	   System.out.println("......................................................");
	   System.out.println(" A pilha ja esta cheia, nao pode receber mais valores ");
	   System.out.println("......................................................");
	   pausa();
	}

  }

  public static void pausa(){
  	String p = "";
  	System.out.println("Aperte qualquer tecla para continuar");
  	p=Keyboard.readString();
  }

  public static void desempilhar(){
  	if(vazia() != 0){
  		vetor[Topo]=0;
  		Topo--;
  	
  		System.out.println("Elemento "+(Topo + 1)+" desempilhado");
    }
    else{
    	System.out.println("A pilha esta vazia, nao ha elementos para desempilhar !!!");
    }
  	pausa();
  }
  
  public static void mostarTopo(){
  	if(vazia() != 0)
  	 System.out.println("Elemento Topo = "+vetor[Topo]);
  	else
  	 System.out.println("A pilha esta vazia."); 
  }
  
  public static void mostrarPilha(){
  	if(vazia() != 0){
  		for(int i=Topo; i >= 1;i--)
  		 System.out.println("O elemento de numero "+ i +" contem o valor "+ vetor[i]);
  	}
  }
  
  public static void sair(){
  	System.out.println("Saindo do programa");
  	pausa();
  }
}







Início

Estruturas de Fila em Java.
 As filas são estruturas baseadas no princípio FIFO (first in, first out),
 em que os elementos que foram inseridos no início são os primeiros a serem removidos.
 Uma fila possui duas funções básicas:
 
 Funções básicas de fila.
  ENQUEUE, que adiciona um elemento ao final da fila.
  DEQUEUE, que remove o elemento no início da fila.
 
 Obs:
 A operação DEQUEUE só pode ser aplicado se a fila não estiver vazia, causando um erro
 de underflow ou fila vazia se esta operação for realizada nesta situação.










Início

Estruturas de Lista em Java.
Uma lista é uma estrutura de dados dinâmica, muito flexível, que permite a fácil inserção e remoção
dos seus elementos.  Cada elemento da lista ligada é chamado nó da lista e contém dois campos:
dados (para armazenar a informação do elemento) e próximo nó - um apontador que contém uma
referencia de memória onde está armazenado o próximo nó da lista.






Para aceder à lista é preciso  definir um apontador InicioLista que aponta ao primeiro nó da lista
(requerido). Para poder aceder ao fim da lista pode ser adicionado um apontador FimLista que aponta
ao último nó da lista (este pode ser introduzido com o objetivo de garantir uma maior rapidez no
aceso ao fim da lista). O próximo nó do último nó da lista é um apontador VAZIO (NULL) que não
aponta para lugar nenhum, indicando o fim da lista. Uma lista vazia é uma lista sem nós. Os nós 
devem ser inseridos e removidos no início da lista ligada.
AdicionarNo:  Insere um novo nó no início da lista 

Sub AdicionarNo(n1, n2)
     1º. Criar novo nó
     2º. Preencher dados
     3º. Preencher ProximoNo do novo nó
     4º. Atualizar apontadores InicioLista e FimLista
End Sub


 

 


Programa básico de lista.

 

  
 public class noDuplo {
    
   int valor;
   noDuplo prox;
   noDuplo ant;

   noDuplo (int ValorNo){
      valor = ValorNo;
      prox = ant = null;
    }
 }
  
  
  
  
  class ListaDupla {
	
   noDuplo primeiro, ultimo;
   int numero_nos;
   ListaDupla(){
	 primeiro = ultimo = null;
	 numero_nos = 0;
   }
   
   void insereNo (noDuplo novoNo){
	  novoNo.prox = null;
	  novoNo.ant = ultimo;
	    if (primeiro == null)
	       primeiro = novoNo;
	       if (ultimo != null)
		      ultimo.prox = novoNo;
		      ultimo = novoNo;
		      numero_nos++;
  }
  noDuplo pegarNo (int indice){
	 noDuplo temp_no = primeiro;
	   for (int i = 0; (i < indice) && (temp_no != null); i++)
	      temp_no = temp_no.prox;
  return temp_no;
  }
  
  void incluiNo (noDuplo novoNo, int indice){
	 noDuplo temp_no = pegarNo (indice);
	 novoNo.prox = temp_no;
	 if (novoNo.prox != null){
	  novoNo.ant = temp_no.ant;
	  novoNo.prox.ant = novoNo;
	 } else {
	  novoNo.ant = ultimo;
	  ultimo = novoNo;
	 }
	 if (indice == 0){
	    primeiro = novoNo;
	 } else {
	    novoNo.ant.prox = novoNo;
	 }
	 numero_nos++;
	}
	
 void excluiNo (int indice){
    if (indice == 0){
       primeiro = primeiro.prox;
       if (primeiro != null)
         primeiro.ant = null;
       } else {
	     noDuplo temp_no = pegarNo (indice);
	     temp_no.ant.prox = temp_no.prox;
	     if (temp_no != ultimo){
	       temp_no.prox.ant = temp_no.ant;
	     } else {
	       ultimo = temp_no;
	     }	    
	   }
	   numero_nos--;
  }
 }
  
  
 
 

  

  
  class usaListaDupla {
	
	 public static void main(String[] args){
      ListaDupla Dlist = new ListaDupla ();
		      Dlist.insereNo (new noDuplo (1));
		      Dlist.insereNo (new noDuplo (3));
		      Dlist.insereNo (new noDuplo (5));
		      Dlist.insereNo (new noDuplo (7));
		      noDuplo temp_no = Dlist.primeiro;
		      while (temp_no != null){
		         System.out.println (temp_no.valor);
		         temp_no = temp_no.prox;
		      }
		      Dlist.incluiNo (new noDuplo (2), 1);
		      System.out.println ("Apos incluir o no 2...");
		      temp_no = Dlist.primeiro;
		      while (temp_no != null){
		         System.out.println (temp_no.valor);
		         temp_no = temp_no.prox;
		      }
		      Dlist.excluiNo (2);
		      System.out.println ("Apos excluir o no 3...");
		      temp_no = Dlist.primeiro;
		      while (temp_no != null){
		         System.out.println (temp_no.valor);
		         temp_no = temp_no.prox;
		      }
		   }
		}
  
  
    
 
 

Início







Ordenação por troca de partição


 

  
class QuickSort{
  public static String s = "";  
  public static void main (String arg [])
{
int num [] = new int [10];
for (int i = 0 ; i < 10 ; i++)
{
 escreva("Digite um número inteiro");
 num[i]= Keyboard.readInt();
}
quicksort(0,num.length-1,num);
for (int i = 0 ; i < num.length ; i++)
{
 s = s + num[i] + " ";
}
 escreva(s);
}
public static void quicksort(int p, int q, int vetor[])
{
int x;
 if (p < q)
 {
  x = particao(p, q, vetor);
  quicksort(p, x - 1, vetor);//Empilhando os valores.
  quicksort(x + 1, q, vetor);//Desempilhando os valores.
 }
}
public static int particao(int p, int q, int vetor[])
{
  int j = p - 1;
  int temp, aux = vetor[q];
  for (int i = p; i <= q; i++)
  {
   if (vetor[i] <= aux)
  {
   j++;
    temp = vetor[i];
    vetor[i] = vetor[j];
    vetor[j] = temp;
  }
 }

 return j;
}

public static void escreva(String x){
    System.out.println(x);
}

}
  
 
 
 



Início