package arquivodecodigos;

public class Estudos{
  public static void main(String[] args){
    String original = "Programar em Java\n é mais fácil do\n que você pensa."; 
    
    // vamos exibir a String original
    System.out.println("Original: " + original);
    
    // agora vamos remover as quebras de linha
    String nova = original.replaceAll("[\\n]", "");
    
    // vamos exibir a String sem as quebras de linha
    System.out.println("Sem quebras de linha: " + nova);
    
    System.exit(0);
  }
} 

// método que permite retornar o maior nó de uma árvore
// binária de busca
public No retornarMaiorElemento(){
  // chama a versão recursiva do método
  return retornarMaiorElemento(raiz);
}
  
public No retornarMaiorElemento(No no){
  if((no == null) || (no.getDireito() == null)){
    return no; // ponto de parada
  }
  else{ // vamos continuar descendo do lado direito
    return retornarMaiorElemento(no.getDireito());
  }
}

package arvore_binaria;

import java.util.Scanner;

public class ArvoreBinariaTeste {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);  
       
    // vamos criar um novo objeto da classe ArvoreBinariaBusca
    ArvoreBinariaBusca arvore = new ArvoreBinariaBusca();
    
    // vamos inserir 5 valores na árvore
    for(int i = 0; i < 5; i++){
      System.out.print("Informe um valor inteiro: ");
      int valor = Integer.parseInt(entrada.nextLine());
       
      // vamos inserir o nó e verificar o sucesso da operação
      if(!arvore.inserir(valor)){
        System.out.println("Não foi possível inserir." +
          " Um elemento já contém este valor.");  
      }
    }
     
    // vamos obter o maior elemento na árvore binária de busca
    System.out.println("\nO maior nó é: " + 
      arvore.retornarMaiorElemento().getValor());
     
    System.out.println("\n");
  }
}

Informe um valor inteiro: 6
Informe um valor inteiro: 13
Informe um valor inteiro: 64
Informe um valor inteiro: 21
Informe um valor inteiro: 3

O maior nó é: 64

Inserindo 5 valores na lista

Informe o 1.o valor: 3
Informe o 2.o valor: 8
Informe o 3.o valor: 4
Informe o 4.o valor: 7
Informe o 5.o valor: 6

Valores na lista: 3 -> 8 -> 4 -> 7 -> 6 -> null

Removendo no início da lista
O nó removido foi: 3

Valores na lista novamente: 8 -> 4 -> 7 -> 6 -> null

package estudos;
  
import java.util.Scanner;

// classe interna usada para representar um
// nó na lista ligada
class No {
  int valor; // valor do nó
  No proximo; // aponta para o novo nó
 
  // construtor cheio da classe No
  public No(int valor, No proximo) {
    this.valor = valor;
    this.proximo = proximo;
  }
  
  // construtor vazio da classe No
  public No() {
    this.valor = 0;
    this.proximo = null;
  }
}

public class Estudos { 
  // vamos criar uma referência para o início da lista
  static No inicio = null;
  
  public static void main(String args[]){
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos inserir 5 valores inteiros na lista ligada
    int valor;
    System.out.println("Inserindo 5 valores na lista\n");
    for (int i = 0; i < 5; i++) {
      System.out.print("Informe o " + (i + 1) + ".o valor: ");
      valor = Integer.parseInt(entrada.nextLine());
      // vamos inserir este valor no final da lista
      inserirFinal(valor);
    }
    
    // vamos exibir os valores na lista ligada
    System.out.print("\nValores na lista: ");
    exibirLista();
    
    // vamos remover o nó no início da lista ligada
    System.out.println("\nRemovendo no início da lista");
    No removido = removerInicio();
    System.out.println("O nó removido foi: " +
      removido.valor);
    
    // vamos exibir os valores na lista ligada
    System.out.print("\nValores na lista novamente: ");
    exibirLista();
  }
  
  // função que permite remover o nó no início de uma lista
  // dinamicamente ligada em Java
  public static No removerInicio() {
    // primeiro apontamos para o início da lista
    No no = inicio;
    
    // a lista está vazia?
    if (no != null) {
      // o início da lista aponta para o seu próximo
      inicio = inicio.proximo;
    }
    
    // retorna o nó removido ou null no caso da lista vazia
    return no;
  }

  // função que permite adicionar um nó no final da
  // lista ligada
  public static void inserirFinal(int valor) {
    // vamos apontar para o nó inicial
    No atual = inicio;
    // criamos um novo nó
    No novo = criarNo(valor);
  
    // a lista ligada ainda está vazia?
    if (atual == null){
      // inicio recebe o novo nó
      inicio = novo;
    }    
    else { // temos um ou mais nós na lista ligada
      // vamos localizar o último nó
      while (atual.proximo != null) {
        atual = atual.proximo;
      }
       
      // encontramos o último nó. Agora vamos inserir
      // o novo nó depois dele
      atual.proximo = novo;
    }
  }
  
  // função usada para construir e retornar um novo nó
  public static No criarNo(int valor) {
    // cria o novo nó
    No no = new No(valor, null);
    // retorna o nó criado
    return no;
  }
  
  // função usada para percorrer a lista ligada e
  // exibir os valores contidos em seus nós
  public static void exibirLista() {
    // vamos apontar para o início da lista
    No temp = inicio;
    
    // a lista está vazia?
    if (temp == null) {
      System.out.println("A lista está vazia.");
    }
    else {
      // esse laço se repete enquanto tempo for
      // diferente de null
      while (temp != null) {
        // vamos mostrar o valor desse nó
        System.out.print(temp.valor + " -> ");
        // avança para o próximo nó
        temp = temp.proximo;
      }
    
      // mostra o final da lista
      System.out.println("null");
    }
  }
}

package arquivodecodigos;

public class Estudos{
  public static void main(String[] args){
    double m[][] = {{1, 2, 3}, {2, 5, 2}, {1, 3, 1}};
    
    // calcula o determinante usando a Regra de Sarrus
    double det = ((m[0][0] * m[1][1] * m[2][2]) + (m[0][1] 
      * m[1][2] * m[2][0]) + (m[0][2] * m[1][0] * m[2][1])) 
      - ((m[2][0] * m[1][1] * m[0][2]) + (m[2][1] 
      * m[1][2] * m[0][0]) + (m[2][2] * m[1][0] * m[0][1]));
    
    System.out.println("O determinante da matriz é: " + det);
  }
}

// vamos criar um vetor de inteiros
int valores[] = {1, 6, 9, 3, 7, 8, 5, 2};

Array na ordem original:
1 6 9 3 7 8 5 2 

Rotação do vetor no passo 1 do primeiro laço:
8 0 0 0 0 0 0 0 

Rotação do vetor no passo 2 do primeiro laço:
8 5 0 0 0 0 0 0 

Rotação do vetor no passo 3 do primeiro laço:
8 5 2 0 0 0 0 0 

Rotação do vetor no passo 1 do segundo laço:
8 5 2 1 0 0 0 0 

Rotação do vetor no passo 2 do segundo laço:
8 5 2 1 6 0 0 0 

Rotação do vetor no passo 3 do segundo laço:
8 5 2 1 6 9 0 0 

Rotação do vetor no passo 4 do segundo laço:
8 5 2 1 6 9 3 0 

Rotação do vetor no passo 5 do segundo laço:
8 5 2 1 6 9 3 7 

Array depois de rotacionar 3 vezes:
8 5 2 1 6 9 3 7

package estudos;

public class Estudos {
  public static void main(String[] args) {
    // vamos criar um vetor de inteiros
    int valores[] = {1, 6, 9, 3, 7, 8, 5, 2};
    
    // mostramos o array na ordem original
    System.out.println("Array na ordem original:");
    exibirVetor(valores);
    
    // vamos rotacionar o array 3 casas para a direita
    valores = rotacionarArray(valores, 3);
    
    // e mostramos o resultado
    System.out.println("Array depois de rotacionar 3 vezes:");
    exibirVetor(valores);
  }
  
  // método usado para exibir o array
  public static void exibirVetor(int []vetor){
    // percorremos cada elemento do vetor
    for (int i = 0; i < vetor.length; i++) {
      System.out.print(vetor[i] + " ");
    }
    System.out.println("\n");
  }
  
  // método que recebe um vetor de inteiros e o rotaciona um
  // determinado número de vezes
  public static int[] rotacionarArray(int[] vetor, int n) {
    // vamos obter a quantidade de elementos no vetor    
    int quant = vetor.length;
    
    // o número de rotações é maior que a quantidade de
    // elementos no vetor? Se for nós ajustamos o número
    // de rotações usando o operador de módulo
    if(n > quant){
      n = n % quant;
    }
    
    // criamos um vetor temporário
    int[] resultado = new int[quant];
 
    // o primeiro laço movimenta os elementos a partir
    // do valor de n
    for(int i = 0; i < n; i++){
      resultado[i] = vetor[quant - n + i];
      // mostramos o progresso
      System.out.println("Rotação do vetor no passo " + (i + 1) + 
        " do primeiro laço:");
      exibirVetor(resultado);
    }
 
    // ajustamos o índice para o primeiro elemento do vetor
    int indice = 0;
    for(int i = n; i < quant; i++){
      resultado[i] = vetor[indice];
      // mostramos o progresso
      System.out.println("Rotação do vetor no passo " + (indice + 1) + 
        " do segundo laço:");
      exibirVetor(resultado);
      indice++; // incrementa o índice
    }
    
    // retorna o vetor rotacionado
    return resultado;
  }
}