------------------------------
        PILHA EM JAVA
------------------------------
1. Empilhar
2. Desempilhar
3. Exibir Pilha
4. Sair
Sua opção: 1

Informe o valor a ser empilhado: 35

Valor empilhado com sucesso.

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

// definição da classe No
public class No {
  int valor; // valor do nó
  No proximo; // aponta para o próximo nó
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

public class Pilha {
  No topo; // aponta para o topo da pilha

  // construtor da classe
  public Pilha() {
    this.topo = null; // pilha vazia
  }
  
  // metodo que permite verificar se a pilha está vazia
  public boolean isVazia(){
    return this.topo == null;
  }
  
  // método que permite empilhar um novo valor na pilha
  public void empilhar(int v){
    // criamos um novo nó
    No novo_no = new No();
    // definimos o valor do nó    
    novo_no.valor = v;
    // apontamos para o nó que estava no topo
    novo_no.proximo = this.topo;
    // e a variável topo agora aponta para o novo nó
    this.topo = novo_no;
  }
  
  // método que permite desempilhar um nó da pilha
  public No desempilhar(){
    // nó a ser retornado
    No removido = null;
    
    // a pilha não está vazia, né?
    if (this.topo != null) {
      // apontamos para o topo da pilha
      No temp = this.topo;
      // agora o topo aponta para o seu próximo
      this.topo = this.topo.proximo;
      // guardamos o valor para retornar no nó removido
      removido = new No();
      removido.valor = temp.valor;
      // e marcamos o nó temp para remoção
      temp = null;
    }
    
    // retorna o nó desempilhado
    return removido;
  }
  
  // método que permite exibir todos os nós da pilha
  public void exibirNos(){
    // vamos apontar para o topo da pilha
    No temp = this.topo;
    
    // enquanto temp for diferente de null
    while (temp != null) {
      System.out.println(temp.valor);
      // pulamos para o próximo nó
      temp = temp.proximo;
    }
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos criar uma nova pilha
    Pilha pilha = new Pilha();
    
    // menu de opções para a pilha
    while(true){
      System.out.println("\n------------------------------");
      System.out.println("        PILHA EM JAVA");
      System.out.println("------------------------------");
      System.out.println("1. Empilhar");
      System.out.println("2. Desempilhar");
      System.out.println("3. Exibir Pilha");
      System.out.println("4. Sair");
      System.out.print("Sua opção: ");
      int opcao = Integer.parseInt(entrada.nextLine());
      
      switch(opcao){
        case 1: // vamos empilhar um novo valor na pilha
          System.out.print("\nInforme o valor a ser empilhado: ");
          int valor = Integer.parseInt(entrada.nextLine());
          pilha.empilhar(valor);
          System.out.println("\nValor empilhado com sucesso.");
          break;
        
        case 2: // vamos desempilhar um valor da pilha
          No desempilhado = pilha.desempilhar();
          if(desempilhado == null){
            System.out.println("\nPilha vazia.");
          }
          else{
            System.out.println("\nO valor desempilhado foi: " +
              desempilhado.valor);
          }
          break;
          
        case 3: // vamos mostrar o conteúdo da pilha
          if(pilha.isVazia()){
            System.out.println("\nA pilha está vazia.");
          }
          else{
            System.out.println("\nElementos na pilha:\n");
            pilha.exibirNos();
          }
          break;
          
        default:
          System.out.println("\nOpção inválida.");
          break;
      }
    }
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

import javax.swing.*;
 
public class Estudos extends JFrame{
  public Estudos() {
    setSize(350, 250);
    setVisible(true);
 
    // Define o título da janela    
    setTitle("Controle de Estoque");
 
    // obtém o título da janela
    JOptionPane.showMessageDialog(null, 
      "O título da janela é: " + this.getTitle());
  }
   
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

// classe No
public class No{
  public int valor;
  public No proximo;
}
// fim da classe No

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public class Lista{
  No inicio; // início da lista  

  // função que permite exibir os valores de
  // todos os nós da lista
  public void exibir(){
    if(inicio != null){
      do{
        System.out.println(inicio.valor);
        inicio = inicio.proximo;
      }while(inicio != null);
    }
    else
      System.out.println("A lista esta vazia\n\n");
  }

  // função que permite inserir nós na lista.
  // veja que a função recebe o valor a ser
  // armazenado em cada nó
  public void inserir(int v){
    No temp;

    // verifica se a lista está vazia
    if(inicio == null){
      // reserva memória para o novo nó
      inicio = new No();
      inicio.valor = v;
      // é o primeiro nó...não deve apontar para
      // lugar nenhum
      inicio.proximo = null;
    }
    else{ // não está vazia....vamos inserir o nó no final
      temp = inicio;
      // vamos varrer a lista até encontrar o último nó
      while(temp.proximo != null)
        temp = temp.proximo;

      // estamos no último nó...vamos criar um novo nó agora
      temp.proximo = new No();
      // atribui o valor do nó
      temp.proximo.valor = v;
      // define o campo proximo do nó como null
      temp.proximo.proximo = null;
    }
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public class TesteLista{
  public static void main(String args[]){
    // vamos criar uma nova lista
    Lista lista = new Lista();

    // vamos inserir quatro valores na lista
    lista.inserir(45);
    lista.inserir(3);
    lista.inserir(98);
    lista.inserir(17);

    // exibe os valores na lista
    lista.exibir();

    System.exit(0);   
  }  
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;
 
public class Estudos{
  // método que permite ordenar o vetor de inteiros
  // usando a ordenação Insertion Sort
  public static void insertionSort(int[] vetor){
    // percorre todos os elementos do vetor começando
    // pelo segundo elemento
    for(int i = 1; i < vetor.length; i++){
      int atual = vetor[i]; // o valor atual a ser inserido
      // começa a comparar com a célula à esquerda de i
      int j = i - 1;
      
      // enquanto vetor[j] estiver fora de ordem em relação
      // a atual
      while((j >= 0) && (vetor[j] > atual)){
        // movemos vetor[j] para a direita e decrementamos j
        vetor[j + 1] = vetor[j];
        j--;
      }
      
      // colocamos atual em seu devido lugar
      vetor[j + 1] = atual;
    }
  }  
    
  public static void main(String args[]){
    // vamos criar um vetor com 9 elementos
    int valores[] = {4, 6, 2, 8, 1, 9, 3, 0, 11};
    
    // exibimos o vetor na ordem original
    System.out.println("Ordem original:\n");
    for(int i = 0; i < valores.length; i++){
      System.out.print(valores[i] + "  ");  
    }
    
    // vamos ordenar o vetor agora
    insertionSort(valores);
    
    // exibimos o vetor ordenado
    System.out.println("\n\nOrdenado:\n");
    for(int i = 0; i < valores.length; i++){
      System.out.print(valores[i] + "  ");  
    }
  }
}