Ejemplo árboles NetBeans

public class Arbol {
    class Nodo
    {
        int info;
        Nodo izq, der;
    }
    Nodo raiz;
    int cant;
    int altura;
    public Arbol() {
        raiz=null;
    }
    public void insertar (int info) {
        if (!existe(info)) {
            Nodo nuevo;
            nuevo = new Nodo ();
            nuevo.info = info;
            nuevo.izq = null;
              nuevo.der = null;
            if (raiz == null)
                raiz = nuevo;
            else {
                Nodo anterior = null, reco;
                reco = raiz;
                while (reco != null)  {
                    anterior = reco;
                    if (info < reco.info)
                        reco = reco.izq;
                    else
                        reco = reco.der;
                }
                if (info < anterior.info)
                    anterior.izq = nuevo;
                else
                    anterior.der = nuevo;
            }
        }
    }
    public boolean existe(int info) {
        Nodo reco=raiz;
        while (reco!=null) {
            if (info==reco.info)
                return true;
            else
                if (info>reco.info)
                    reco=reco.der;
                else
                    reco=reco.izq;
        }
        return false;
    }
    private void imprimirEntre (Nodo reco)  {
        if (reco != null)  {
            imprimirEntre (reco.izq);
            System.out.print(reco.info + " ");
            imprimirEntre (reco.der);
        }
    }
    public void imprimirEntre () {
        imprimirEntre (raiz);
        System.out.println();
    }

    private void cantidad(Nodo reco) {
        if (reco!=null) {
            cant++;
            cantidad(reco.izq);
            cantidad(reco.der);
        }
    }
    public int cantidad() {
        cant=0;
        cantidad(raiz);
        return cant;
    }
    private void cantidadNodosHoja(Nodo reco) {
        if (reco!=null) {
            if (reco.izq==null && reco.der==null)
                cant++;
            cantidadNodosHoja(reco.izq);
            cantidadNodosHoja(reco.der);
        }
    }
    public int cantidadNodosHoja() {
        cant=0;
        cantidadNodosHoja(raiz);
        return cant;
    }
    private void imprimirEntreConNivel (Nodo reco,int nivel)  {
        if (reco != null) {
            imprimirEntreConNivel (reco.izq,nivel+1);
            System.out.print(reco.info + " ("+nivel+") - ");
            imprimirEntreConNivel (reco.der,nivel+1);
        }
    }
    public void imprimirEntreConNivel () {
        imprimirEntreConNivel (raiz,1);
        System.out.println();
    }
    private void retornarAltura (Nodo reco,int nivel)    {
        if (reco != null) {
            retornarAltura (reco.izq,nivel+1);
            if (nivel>altura)
                altura=nivel;
            retornarAltura (reco.der,nivel+1);
        }
    }
    public  int retornarAltura () {
        altura=0;
        retornarAltura (raiz,1);
        return altura;
    }
    public void mayorValorl() {
        if (raiz!=null) {
            Nodo reco=raiz;
            while (reco.der!=null)
                reco=reco.der;
            System.out.println("Mayor valor del įrbol:"+reco.info);
        }
    }
    public void borrarMenor() {
        if (raiz!=null) {
            if (raiz.izq==null)
                raiz=raiz.der;
            else {
                Nodo atras=raiz;
                Nodo reco=raiz.izq;
                while (reco.izq!=null) {
                    atras=reco;
                    reco=reco.izq;
                }
                atras.izq=reco.der;
            }
        }
    }
    public static void main (String [] ar)
    {
        Arbol abo = new Arbol ();
        abo.insertar (100);
        abo.insertar (50);
        abo.insertar (25);
        abo.insertar (75);
        abo.insertar (150);
        System.out.println ("Impresion entreorden: ");
        abo.imprimirEntre ();
        System.out.println ("Cantidad de nodos del įrbol:"+abo.cantidad());
        System.out.println ("Cantidad de nodos hoja:"+abo.cantidadNodosHoja());
        System.out.println ("Impresion en entre orden junto al nivel del nodo.");
        abo.imprimirEntreConNivel();
        System.out.print ("Artura del arbol:");
        System.out.println(abo.retornarAltura());
        abo.mayorValorl();
        abo.borrarMenor();
        System.out.println("Luego de borrar el menor:");
        abo.imprimirEntre ();
    }
}

Los árboles en Estructura de Datos.-

Un árbol es una estructura de datos ampliamente usada que imita la forma de un árbol (un conjunto de nodos conectados). 

Estos nodos son las unidades sobre la que se construye el árbol y puede tener cero o más nodos hijos conectados a él. 

Se dice que un nodo  es padre de un nodo  si existe un enlace desde  hasta  (en ese caso, también decimos que  es hijo de ). Sólo puede haber un único nodo sin padres, que llamaremos raíz. Un nodo que no tiene hijos se conoce como hoja. Los demás nodos (tienen padre y uno o varios hijos) se les conoce como rama.

Uso de los árboles.-

• Representación de datos en jerarquía.
• Como ayuda para realizar búsquedas en conjuntos de datos.

Formalmente, podemos definir un árbol de la siguiente forma:

• Caso base: un árbol con sólo un nodo (es a la vez raíz del árbol y hoja).

• Un nuevo árbol a partir de un nodo  y  árboles  de raíces  con  elementos cada uno, puede construirse estableciendo una relación padre-hijo entre  y cada una de las raíces de los  árboles. 

Una sucesión de nodos del árbol, de forma que entre cada dos nodos consecutivos de la sucesión haya una relación de parentesco, decimos que es un recorrido árbol. Existen dos recorridos típicos para listar los nodos de un árbol: primero en profundidad y primero en anchura. En el primer caso, se listan los nodos expandiendo el hijo actual de cada nodo hasta llegar a una hoja, donde se vuelve al nodo anterior probando por el siguiente hijo y así sucesivamente. En el segundo, por su parte, antes de listar los nodos de nivel  (a distancia  aristas de la raíz), se deben haber listado todos los de nivel . Otros recorridos típicos del árbol son preorden, postorden e inorden:

• El recorrido en preorden, también llamado orden previo consiste en recorrer en primer lugar la raíz y luego cada uno de los hijos  en orden previo.
• El recorrido en inorden, también llamado orden simétrico (aunque este nombre sólo cobra significado en los árboles binarios) consiste en recorrer en primer lugar , luego la raíz y luego cada uno de los hijos  en orden simétrico.
• El recorrido en postorden, también llamado orden posterior consiste en recorrer en primer lugar cada uno de los hijos  en orden posterior y por último la raíz.

Operaciones básicas con árboles.-

Las operaciones comunes en árboles son:

• Enumerar todos los elementos.
• Buscar un elemento.
• Dado un nodo, listar los hijos (si los hay).
• Borrar un elemento.
• Eliminar un subárbol (algunas veces llamada podar).
• Añadir un subárbol (algunas veces llamada injertar).
• Encontrar la raíz de cualquier nodo.

Por su parte, la representación puede realizarse de diferentes formas. Las más utilizadas son:

• Representar cada nodo como una variable en el heap, con punteros a sus hijos y a su padre.
• Representar el árbol con un array donde cada elemento es un nodo y las relaciones padre-hijo vienen dadas por la posición del nodo en el array.

Clasificación de árboles.-

Árbol Binario.-

En ciencias de la computación, un árbol binario es una estructura de datos en la cual cada nodo siempre tiene un hijo izquierdo y un hijo derecho. No pueden tener más de dos hijos (de ahí el nombre "binario"). Si algún hijo tiene como referencia a null, es decir que no almacena ningún dato, entonces este es llamado un nodo externo. En el caso contrario el hijo es llamado un nodo interno. Usos comunes de los árboles binarios son los árboles binarios de búsqueda, los montículos binarios y Codificación de Huffman. 

Un árbol ordenado es aquel en el que las ramas  de los nodos del árbol están  ordenadas. Los árboles ordenados de grado 2 son de especial interés puesto que  representan una de las estructuras de  datos más importantes en computación, conocidas como  árboles binarios. En un árbol binario cada nodo puede tener como máximo dos subárboles y  siempre es necesario distinguir entre el subárbol izquierdo y el subárbol derecho.

Formalmente podemos definir un árbol binario de tipo T como una estructura homogénea que es la concatenación de un elemento de tipo T, llamada raíz, con dos árboles binarios disjuntos. Una forma  particular de árbol binario puede ser la estructura vacía. 

Los árboles binarios  se clasifican en cuatro tipo que son : distintos, similares, equivalentes y completos. Cuando dos  árboles binarios se dice que son similares si tiene la misma estructura y son equivalentes  si son similares  y contienen la misma información. En caso contrario  se dice que  estos árboles son distintos. Un arbol binario esta equilibrado  si la altura de los dos subárboles  de cada nodo del arbol  se diferencia en una unidad como máximo. 

El procedimiento de arbol binarios equilibrados es mas sencillo que los árboles no equilibrados.

Pila dinámica; Ejemplo NetBeans.

import java.util.*;

public class PilaDinamica {
    public static void main(String[] args) {
        Scanner leer =new Scanner(System.in);
        int num;
        int op;
        LinkedList lista = new LinkedList();
        do{
            System.out.println("\t Menuº \t");
            System.out.println("Operaciones con pilas");
            System.out.println("1.- Insertar");
            System.out.println("2.- Borrar");
            System.out.println("3.- Mostrar la pila");
            System.out.println("4.- Salir");
            System.out.println("\n");
            System.out.println("Elija la operación que desee");
            op =leer.nextInt();
            switch(op){
            case 1:
                System.out.println("Inserte Numero");
                num =leer.nextInt();
                lista.addLast(num);
                break;
            case 2:
                System.out.println("SE borrará el nodo final");
                lista.removeFirst();
                break;
            case 3:
                System.out.println("La lista es la siguiente");
                 List lista2 = new ArrayList (lista);
                 Iterator it = lista2.iterator();
                
                 while (it.hasNext()){
                     System.out.println(it.next() + "");
                 }
                 break;
            case 4:
                System.out.println("Al rato");
                break;
            }
        }
        while(op != 4);
    }
}

Cola estática; Ejemplo NetBeans.

package colaestatica;
import java.util.Scanner;
public class colaestatica {
public static int op;
public static int tope;
    int cola[]= new int[10];
    public void insertar(){
        if(tope==10)
            System.out.println("La cola está llena");
        else
    {
       for(int i=0;i<cola.length;i++ ){
        System.out.println("Proporciona el dato para la Cola");
        System.out.println("dato " + tope);
        Scanner cap= new Scanner(System.in);
        cola[tope]=cap.nextInt();
        tope++;
    } }
}
    public void imprimir(){
       if(tope>0){
            for(int topeL=0;topeL<10;topeL++){
                System.out.println("\n\n" + cola [topeL]);
                System.out.println(tope);
            }
        }
        else
            System.err.println("Cola vacía; no hay nada que mostrar");
    }
    public void eliminar(){
        if(tope<0){
            System.out.println("cola vacia");
        }
        else
                for(int topeL=0;topeL<10;topeL++){
                     cola[topeL]=0;
            }
            }
    public static void main(String[] args) {
       cola_estatica p = new cola_estatica();
       String r;
       Scanner cap1=new Scanner(System.in);
       Scanner cap=new Scanner(System.in);
       tope=0;
       do{
           System.out.println("Menu principal:\n¿Qué desea hacer con la pila?");
           System.out.println("1.- Insertar");
           System.out.println("2.- Eliminar");
           System.out.println("3.- Imprimir");
           System.out.println("4.- Salir");
           op=cap.nextInt();
           switch(op){
               case 1: p.insertar();break;
               case 2:p.eliminar();break;
               case 3:p.imprimir();break;
               case 4:break; default:
                   System.out.println("Opción no válida; intente de nuevo");break;
           }
    }while(op!=4);
}}