presentacion

Crea archivo de datos

Programa que crea un archivo de datos

import java.io.*;
import javax.swing.*;

public class CrearArchivoAleatorio {
   
    private static final int NUMERO_REGISTROS = 100;

   // permitir al usuario seleccionar el archivo a abrir
   private void crearArchivo()
   {
      // mostrar cuadro de diálogo para que el usuario pueda seleccionar el archivo
      JFileChooser selectorArchivo = new JFileChooser();
      selectorArchivo.setFileSelectionMode( JFileChooser.FILES_ONLY );

      int resultado = selectorArchivo.showSaveDialog( null );
  
      // si el usuario hizo clic en el botón Cancelar del cuadro de diálogo, regresar
      if ( resultado == JFileChooser.CANCEL_OPTION )
         return;

      // obtener el archivo seleccionado
      File nombreArchivo = selectorArchivo.getSelectedFile();

      // mostrar error si el nombre del archivo es inválido
      if ( nombreArchivo == null || nombreArchivo.getName().equals( "" ) )
         JOptionPane.showMessageDialog( null, "Nombre de archivo incorrecto",
            "Nombre de archivo incorrecto", JOptionPane.ERROR_MESSAGE );

      else {

         // abrir el archivo
         try {          
            RandomAccessFile archivo =
               new RandomAccessFile( nombreArchivo, "rw" );

            RegistroCuentasAccesoAleatorio registroEnBlanco =
               new RegistroCuentasAccesoAleatorio();

            // escribir 100 registros en blanco
            for ( int cuenta = 0; cuenta < NUMERO_REGISTROS; cuenta++ )
               registroEnBlanco.escribir( archivo );

            archivo.close(); // cerrar el archivo

            // mostrar mensaje indicando que el archivo se creó
            JOptionPane.showMessageDialog( null, "Se creó el archivo " +
               nombreArchivo, "Estado", JOptionPane.INFORMATION_MESSAGE );

            System.exit( 0 );  // terminar el programa

         } // fin del bloque try

         // procesar excepciones durante operaciones de apertura, escritura o cierre del archivo
         catch ( IOException excepcionES ) {
            JOptionPane.showMessageDialog( null, "Error al procesar el archivo",
               "Error al procesar el archivo", JOptionPane.ERROR_MESSAGE );

            System.exit( 1 );
         }

      } // fin de instrucción else

   } // fin del método crearArchivo

   public static void main( String args[] )
   {
      JDialog.setDefaultLookAndFeelDecorated(true);
      CrearArchivoAleatorio aplicacion = new CrearArchivoAleatorio();
      aplicacion.crearArchivo();
   }  

} // fin de la clase CrearArchivoAleatorio

Programa con metodos de ordenamiento y busqueda

Programa que utiliza los metodos de ordenacion y busqueda interna


import javax.swing.*;
public class buscar{

    static int obj,index=0,cont=0;
    static int vector[]=new int[5];

    static int BuscarNum(int vector[],int obj,int index){
   
        if(index>4)
        JOptionPane.showMessageDialog(null,"Se ha terminado de buscar");
        else{
            if(vector[index]==obj){
                cont=1+cont;
                BuscarNum(vector,obj,index+1);
            }
            else
            BuscarNum(vector,obj,index+1);
        }
        return cont;
    }

    public static void main(String args[]){
        JOptionPane.showMessageDialog(null,"Llena un vector de 5 posiciones");
        for(int x=0;x<5;x++)
        vector[x]=Integer.parseInt(JOptionPane.showInputDialog(null,"Posicion "+(index+1)));
        obj=Integer.parseInt(JOptionPane.showInputDialog(null,"Numero a buscar"));

        JOptionPane.showMessageDialog(null,"El número a sido encontrado "+BuscarNum(vector,obj,index)+" veces");
    }
}

Programa animado

Hacer un programa que manipule una lista o una pila o una cola pero que se vea la animacion de la operacion realizada

import javax.swing.*;
public class cola{
    class Nodo {
        int info;
        Nodo sig;
    }
    private Nodo raiz;
    public cola(){
        raiz=null;
    }
    public void insertar (int x){
        Nodo nuevo;
        nuevo=new Nodo();
        nuevo.info=x;
        if(raiz==null)
        {
            nuevo.sig=null;
            raiz=nuevo;
        }
        else
        {
            nuevo.sig=raiz;
            raiz=nuevo;
        }
    }
    public int extraer ()
{
    if (raiz!=null)
{
int informacion=raiz.info;
raiz=raiz.sig;
return informacion;
}
else
{
return Integer.MAX_VALUE;
}
}
public void imprimir (){
Nodo reco=raiz;
System.out.println("Elementos de la cola. ");
while(reco!=null){
System.out.print(reco.info+"_");
reco=reco.sig;
}
System.out.println();
}
public static void main(String[]arg) {
pila2 pila1=new pila2();
int op=4,dato;
do{
String menu="\n\n menu de opciones\n\n1) Insertar\n2)Eliminar\n3)Listar\n4)Salir\n\nElige una opcion:";
op=Integer.parseInt(JOptionPane.showInputDialog(menu));
switch(op){
case 1:dato=Integer.parseInt(JOptionPane.showInputDialog("Dato a insertar"));
    pila1.insertar(dato);
break;
case 2:dato=pila1.extraer();
 JOptionPane.showMessageDialog(null,"El dato eliminado es: "+dato);
break;
case 3:pila1.imprimir();
break;
case 4:JOptionPane.showMessageDialog(null,"fin del programa");
}
}while(op!=4);
}
}

investigación

En ciencias de la informática, un árbol es una estructura de datos ampliamente usada que imita la forma de un árbol (un conjunto de nodos conectados). Un nodo es la unidad sobre la que se construye el árbol y puede tener cero o más nodos hijos conectados a él. Se dice que un nodo a es padre de un nodo b si existe un enlace desde a hasta b (en ese caso, también decimos que b es hijo de a). 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.

Definición

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 n_r y k árboles de raíces con elementos cada uno, puede construirse estableciendo una relación padre-hijo entre n_r y cada una de las raíces de los k árboles. El árbol resultante de nodos tiene como raíz el nodo n_r, los nodos son los hijos de n_r y el conjunto de nodos hoja está formado por la unión de los k conjuntos hojas iniciales. A cada uno de los árboles A_i se les denota ahora subárboles de la raíz.

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 n + 1 (a distancia n + 1 aristas de la raíz), se deben haber listado todos los de nivel n. 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 A₁, 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.

Finalmente, puede decirse que esta estructura es una representación del concepto de árbol en teoría de grafos. Un árbol es un grafo conexo y acíclico.

Tipos de árboles

Ejemplo de árbol (binario).

• Árboles Binarios
  • Árbol de búsqueda binario auto-balanceable
    • Árboles AVL
    • Árboles Rojo-Negro
    • Árbol AA
• Árboles Multicamino
  • Árboles B (Arboles de búsqueda multicamino autobalanceados)
    • Árbol-B+
    • Árbol-B*

[editar] Operaciones de árboles. Representación

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.

Programa Cola

Hacer un programa que manipule una cola. Debe tener los metodos para insertar, eliminar y recorrer la cola en una lista enlazada.
Colas
Las colas son una subclase de las listas lineales que siguen el orden FIFO (First Input First Output - Primero en entrar Primero en salir). Este orden es que siguen las filas que hacemos en la vida cotidiana al ir al banco, las tortillas, etc. En las colas la inserción se hace al final y la eliminación se hace al frente, por lo que se hace necesario el uso de una variable Primero y otra variable Último por medio de las cuales se llevaran a cabo las operaciones.

import javax.swing.*;
public class cola{
    class Nodo {
        int info;
        Nodo sig;
    }
    private Nodo raiz;
    public cola(){
        raiz=null;
    }
    public void insertar (int x){
        Nodo nuevo;
        nuevo=new Nodo();
        nuevo.info=x;
        if(raiz==null)
        {
            nuevo.sig=null;
            raiz=nuevo;
        }
        else
        {
            nuevo.sig=raiz;
            raiz=nuevo;
        }
    }
    public int extraer ()
{
    if (raiz!=null)
{
int informacion=raiz.info;
raiz=raiz.sig;
return informacion;
}
else
{
return Integer.MAX_VALUE;
}
}
public void imprimir (){
Nodo reco=raiz;
System.out.println("Elementos de la cola. ");
while(reco!=null){
System.out.print(reco.info+"_");
reco=reco.sig;
}
System.out.println();
}
public static void main(String[]arg) {
pila2 pila1=new pila2();
int op=4,dato;
do{
String menu="\n\n menu de opciones\n\n1) Insertar\n2)Eliminar\n3)Listar\n4)Salir\n\nElige una opcion:";
op=Integer.parseInt(JOptionPane.showInputDialog(menu));
switch(op){
case 1:dato=Integer.parseInt(JOptionPane.showInputDialog("Dato a insertar"));
    pila1.insertar(dato);
break;
case 2:dato=pila1.extraer();
 JOptionPane.showMessageDialog(null,"El dato eliminado es: "+dato);
break;
case 3:pila1.imprimir();
break;
case 4:JOptionPane.showMessageDialog(null,"fin del programa");
}
}while(op!=4);
}
}

Pila modificada

Subir el programa de pila personalizado

 mport javax.swing.*;
public class pila2 {
    class Nodo {
        int info;
        Nodo sig;
    }
    private Nodo raiz;
    public pila2 (){
        raiz=null;
    }
    public void insertar (int x){
        Nodo nuevo;
        nuevo=new Nodo();
        nuevo.info=x;
        if(raiz==null)
        {
            nuevo.sig=null;
            raiz=nuevo;
        }
        else
        {
            nuevo.sig=raiz;
            raiz=nuevo;
        }
    }
    public int extraer ()
{
    if (raiz!=null)
{
int informacion=raiz.info;
raiz=raiz.sig;
return informacion;
}
else
{
return Integer.MAX_VALUE;
}
}
public void imprimir (){
Nodo reco=raiz;
System.out.println("Listado de todos los elementos de la pila. ");
while(reco!=null){
System.out.print(reco.info+"_");
reco=reco.sig;
}
System.out.println();
}
public static void main(String[]arg) {
pila2 pila1=new pila2();
int op=4,dato;
do{
String menu="\n\n menu de opciones\n\n1) Insertar\n2)Eliminar\n3)Listar\n4)Salir\n\nElige una opcion:";
op=Integer.parseInt(JOptionPane.showInputDialog(menu));
switch(op){
case 1:dato=Integer.parseInt(JOptionPane.showInputDialog("Dato a insertar"));
    pila1.insertar(dato);
break;
case 2:dato=pila1.extraer();
 JOptionPane.showMessageDialog(null,"El dato eliminado es: "+dato);
break;
case 3:pila1.imprimir();
break;
case 4:JOptionPane.showMessageDialog(null,"fin del programa");
}
}while(op!=4);
}
}