Listas Dobles

Las listas doblemente enlazadas son estructuras datos similares a las listas enlazadas simples. Ya que sus extremos apuntan a nulo lo que le diferencia es que tiene dos enlaces donde uno que apunta hacia el elemento anterior y otro que apunta hacia el elemento siguiente.

El enlace anterior del primer elemento debe apuntar hacia NULL (el inicio de la lista).
El enlace siguiente del último elemento debe apuntar hacia NULL (el fin de la lista).

Nosotros podemos recorrer la lista como lo hacíamos con una lista simple (comenzando por el inicio, el enlace siguiente permite el desplazamiento hacia el próximo elemento). O lo podemos hacer mediante el enlace anterior desplazamos hacia los elementos anteriores.

A continuación realizaremos los métodos de ingresar datos a una lista enlazada ya sea por inicio, fin. Como también eliminar inicio o eliminar fin y muchos otros métodos más que son muy importante aprenderlos para un buen manejo de las listas enlazadas dobles. Esto lo realizaremos para datos de tipo objeto e implementaremos en una interfaz, para su mejor visualización (gráficos).

Descargar Proyecto -->  ;)

Lista Circular

Las listas circulares son estructuras de datos en la que el último nodo apunta al primero lo cual la convierte en una lista sin fin, cada nodo siempre tiene uno anterior y uno siguiente, su estructura es muy similar a las listas simples por lo cual comparten características tanto en su implementación como en su manejo aunque requiere un mayor entendimiento del manejo de los punteros.

• No existe ningún nodo que apunte a null.

• La lista no tiene fin ya que al llegar al último nodo empieza de nuevo la lista.

• Se accede a la lista mediante el primer nodo o también llamado inicio de la lista.

• Si no se tiene cuidado al manejar la lista circular se pueden crear bucles infinitos.
• No tiene acceso aleatorio es decir para acceder a un valor se debe recorrer toda la lista

Un ejemplo utilizando Lista Circula:

Programa en el cual ingresamos Frutas; su código, nombre y precio. En el cual podamos agregarlo al inicio, final o entre nodos.
Como también podamos eliminar inicio, final o por nodos.
Así también modificar una fruta o buscar una fruta en específica. Y también la opción de poder eliminar todas las frutas de la lista.

Además de ello simular mediante gráfico, cómo estas frutas se van enlazando.
Mostrando todas las frutas ingresadas en una JTextArea.

Enlace de descarga:

Lista Enlazada Simple

En ciencias de la computación, una lista enlazada es una de las estructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. 

Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias, enlaces o punteros al nodo anterior o posterior. 

El principal beneficio de las listas enlazadas respecto a los vectores convencionales es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento.

Un ejemplo de lista enlazada simple:

Programa en el cual ingresamos Frutas; su código, nombre y precio. En el cual podamos agregarlo al inicio, final o entre nodos.

Como también podamos eliminar inicio, final o por nodos.

Así también modificar una fruta o buscar una fruta en específica. Y también la opción de poder eliminar todas las frutas de la lista.

Además de ello simular mediante gráfico, cómo estas frutas se van enlazando.

Mostrando todas las frutas ingresadas en una JTextArea.

Enlace de descarga

TRABAJO GRUPAL

ORDENAMIENTO Y BÚSQUEDA

El día de hoy explicaremos como funciona el método de ordenamiento QuickSort, conocido por ser el más rápido y por ello eficiente ya que reduce recurso y sobre todo optimiza nuestro código. Y también explicaremos la Búsqueda Binaria, donde esta búsqueda es mucho más eficiente que otras; Y ese es el propósito de nuestro blogger. "OPTIMIZAR".

Ordenamiento Rápido (QuickSort):

Este algoritmo fue propuesto por Charles Antony Richard Hoare en 1960. En este método se recalca esta frase "Divide y vencerás"; ya que dicho método consiste en esto, ya que divide a nuestro arreglo en sub-arreglos y aplica este mismo método en los sub-arreglos. A esto se le llama recursividad y nuestro ordenamiento rápido funciona por ello.

A continuación el método de Ordenamiento QuickSort:

public class Metodos {
     
      public int[] quicksort2(int numeros[], int izq, int dere) {
        if (izq>=dere) 
            return numeros;
        int i=izq,d=dere;
        if (izq !=dere) {
            int pivote;
            int aux;
            pivote=dere;
            while (izq!= dere) {
                while (numeros[pivote] > =numeros[izq] && izq < dere) 
                    izq++;   
                  while (numeros[pivote] < numeros[der] && izq < dere) {
                        dere--; }  
                
                if(dere!=izq){
                
                    aux=numeros[dere];
                    numeros[dere]=numeros[izq];
                    numeros[izq]=aux;}
            }
            if (izq==dere) {
                quicksort2(numeros, i, izq-1);
                quicksort2(numeros, izq+1, d);
            }
            
        }else
            return numeros;
             
        return numeros;
    }
}

Búsqueda Binaria:

Cabe mencionar que, el método funciona si el vector esta ordenado; con cualquier método de ordenamiento. Con este método se examina primero el elemento medio del arreglo; si este es el elemento buscado entonces la búsqueda ha terminado. En caso contrario se determina si el elemento buscado está en la primera o segunda mitad del arreglo y a continuación se repite el proceso anterior, utilizando el elemento medio del arreglo de esta sublista.

A continuación el método de Búsqueda Binaria:

public class Metodos {
     
    public int busquedbinaria(int array[],int cantidad, int num) {
        int tam = cantidad;
        int min = 0, med = 0, max = tam;
        while (min <= max) {
            med = (min + max) / 2;
            if (num == array[med]) {
                System.out.println("ES CIERTO SALE DEL BUCLE ");
                break;
            }
            if (num < array[med]) {
                max = med;
            } else {
                min = med;
              }
        }
        return med;
    } 
}

Estos métodos lo implementamos en una Interface, para una mejor visualización y comprensión de los métodos. Ademas de ello los datos guardados se guardan en un Archivo txt. 
El programa lo dejare en el link de descarga para que puedan estudiarlo.

Link de Descarga:    AQUI !!!

Examen Parcial

ARREGLOS INTERFACES Y ARCHIVOS

La funcionalidad del Programa es que agrega aleatoriamente números enteros en la array. si el numero aleatorio es Impar lo agrega por pila y si el numero es Par lo agrega por cola. Donde aquí vemos como funcionan los métodos de Pilas y colas.

También Podemos sacar del arreglo los números múltiplos de dos.

Ademas de ello. El botón eliminar aleatorio, elimina un numero alzar del vector ya sea por pila o por cola.

Un botón ordenar, que me ordena el arreglo de forma descendente.
Y por ultimo un botón que realizara el conteo de la cantidad de los números pares que tiene mi arreglo.

Cabe mencionar que se implementaron los métodos en una interfaz, y ademas de ello estos datos generados se  guardaban en un archivo: llamado: D:/aleatorio.txt  que tenia la dirección del disco D.

Link de Descarga:      AQUI !!

PILAS Y COLAS

¿Que son Pilas y Colas?

Las pilas y colas son estructuras de datos que se utilizan generalmente para simplificar ciertas operaciones de programación. Estas estructuras pueden implementarse mediante arrays o mediante listas enlazadas; en estos ejemplos solo trabajaremos con arrays.

Pilas: 

Las pilas son estructuras de datos que tienes dos operaciones básicas: push (para insertar un elemento) y pop (para extraer un elemento). Su característica fundamental es que al extraer se obtiene siempre el último elemento que acaba de insertarse.

Las pilas se utilizan en muchas aplicaciones que utilizamos con frecuencia. Por ejemplo, la gestión de ventanas en Windows (cuando cerramos una ventana siempre recuperamos la que teníamos detrás). 

Colas: 

Las colas también son FIFO (First In First Out), que quiere decir “el primero que entra es el primero que sale”.

Se inserta por un sitio y se saca por otro, en el caso de la cola simple se inserta por el final y se saca por el principio. Para gestionar este tipo de cola hay que recordar siempre cual es el siguiente elemento que se va a leer y cual es el último elemento que se ha introducido.

Ejemplo Practico:

A continuación realizaremos un Array donde podamos agregar por pila y por cola números enteros.  Y de igual forma implementaremos los métodos de eliminar por pila y por cola.

Para ello Utilizaremos Interfaces donde implementaremos los botones de agregar por pila y por cola; y a su vez eliminar. Ademas de ello los datos agregados y eliminados se guardaran en un archivo llamado D:/PilasColas.txt; localizado en nuestro disco D.

INTERFACE:

Link de Descarga:     Programa Completo

Archivos

ARCHIVOS JAVA(FICHEROS)

un fichero es un registro o una base de datos donde se almacenan los datos de tipo String 

al momento de ser creados estos pueden estar llevadas hasta la dirección que tu le das mediante el código.

Mediante esta clase llamada fichero útil nosotros podemos llamarla y poder guardar nuestro array de objetos y poder leerlo desde un archivo guardado.

import java.io.*;
import java.util.StringTokenizer;


public class ficheroUtil {
 
    public static final String direccionFicheroRegistro= "D:/alumno/registro.txt";
    public static final String direccionFicheroRegistroEliminado= "D:/alumno/registroEliminado.txt";
 
    private static int codigoNew;
 
    private static boolean existeDato = false;
    File fichero;
    public void CrearArchivo(String direccion){
        try {
            fichero = new File(direccion);
            if(!fichero.exists()){
                fichero.createNewFile();
            }
         
        } catch (Exception e) {
            System.out.println("problemas");
        }
    }
    public void agregarDatos(String Datos[],int cont,String direccion){
        try {
            CrearArchivo(direccion);
            FileWriter fw = new FileWriter(fichero);
            BufferedWriter bw = new BufferedWriter(fw);
            for (int i = 0; i <= cont; i++) {
                bw.write(Datos[i]);
                bw.newLine();
            }
            System.out.println("datos agregados");
            bw.close();
        } catch (Exception e) {
            System.out.println("problemas");
        }
    }
    public void LeerArchivoAlumno(alumno est[],String direccion){
        int i = 0;
        try{
            CrearArchivo(direccion);
            FileReader fr = new FileReader(fichero);
         
            BufferedReader br = new BufferedReader(fr);
            String cadena;
            while((cadena = br.readLine())!=null){
StringTokenizer st = new StringTokenizer (cadena,",");
                System.out.println(cadena);
                est[i] = new alumno();
                est[i].setNombre(st.nextToken());
                est[i].setCodigo(Integer.parseInt(st.nextToken()));
                est[i].setEdad(Integer.parseInt(st.nextToken()));
                est[i].setFacultad(st.nextToken());
                i++;
                this.setCodigoNew(est[i-1].getCodigo()+1);
             
                this.setExisteDato(true);
            }
            System.out.println("EL CODIGO NUEVO ES : "+i);
            br.close();
        }catch(FileNotFoundException e){
e.printStackTrace();
        }catch (IOException e) {
e.printStackTrace();
}
 
    }