Colas en Estructura de Datos

Concepto.- Es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir. Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas enlazadas.

http://es.wikipedia.org/wiki/Cola_%28inform%C3%A1tica%29

Operaciones Basicas.-

• Crear: se crea la cola vacía.
• Encolar (añadir, entrar, insertar): se añade un elemento a la cola. Se añade al final de esta.
• Desencolar (sacar, salir, eliminar): se elimina el elemento frontal de la cola, es decir, el primer elemento que entró.
• Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primer elemento que entró.

http://es.wikipedia.org/wiki/Cola_%28inform%C3%A1tica%29


Tipos De Colas.-

• Colas circulares (anillos): en las que el último elemento y el primero están unidos.

• Colas de prioridad: En ellas, los elementos se atienden en el orden indicado por una prioridad asociada a cada uno. Si varios elementos tienen la misma prioridad, se atenderán de modo convencional según la posición que ocupen. Hay 2 formas de implementación:

1. Añadir un campo a cada nodo con su prioridad. Resulta conveniente mantener la cola ordenada por orden de prioridad.
2. Crear tantas colas como prioridades haya, y almacenar cada elemento en su cola.

• Bicolas: son colas en donde los nodos se pueden añadir y quitar por ambos extremos; se les llama DEQUE (Double Ended QUEue). Para representar las bicolas lo podemos hacer con un array circular con Inicio y Fin que apunten a cada uno de los extremos. Hay variantes:

• Bicolas de entrada restringida: Son aquellas donde la inserción sólo se hace por el final, aunque podemos eliminar al inicio ó al final.

• Bicolas de salida restringida: Son aquellas donde sólo se elimina por el final, aunque se puede insertar al inicio y al final.

http://es.wikipedia.org/wiki/Cola_%28inform%C3%A1tica%29

Pila Estatica

 public static void main(String[] args) {
       
       int dato=0;
       int pila[]= new int[5];
       Scanner captura = new Scanner(System.in);
       for(int tope=0; tope<4;  tope++)
          
          
       {
           System.out.println("Proporcione datos para pila");
           dato = captura.nextInt();
           pila[tope]= dato;
        }
       for(int tope = 4; tope>=0; tope--)
            System.out.println("La pila tiene los siguientes datos:" + pila[tope]);
   
      
  
}
}

Pilas

Concepto.- Se comienza definiendo lo que es una pila a nivel de programación;

pila es una estructura de datos en la que la inserción y la extracción de elementos se realiza sólo por un extremo que se denomina cabeza. como consecuencia, los elementos de una pila serán eliminados en orden inverso al que se insertaron. es decir, el último elemento que se metió en la pila será el primero en salir de ella.

debido al orden en que se insertan y eliminan los elementos en una pila, también se le conoce como estructura lifo (last in, first out: último en entrar, primero en salir).

http://www.tonahtiu.com/notas/estructuras/pila_concepto.htm

Aplicaciones.- Las pilas son utilizadas ampliamente para solucionar una amplia variedad de problemas. Se utiliza en compiladores, sistemas operativos y en programas de aplicación. Su implementación se puede hacer mediante Arrays Y Mediante listas enlazadas.

http://es.wikipedia.org/wiki/Pila_(inform%C3%A1tica)

Un ejemplo de sus aplicaciones podrían ser los siguientes:

• Los Navegadores en Internet almacenan en una pila las direcciones de los sitios más recientemente visitados.
• Los editores de texto proporcionan normalmente un botón deshacer que cancela las operaciones de edición recientes y restablece el estado anterior del documento.

http://www.monografias.com/trabajos44/pilas-listas-expresiones/pilas-listas-expresiones2.shtml

operaciones.- Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen añadir más de uso habitual.

• Crear: se crea la pila vacía.
• Apilar: se añade un elemento a la pila.(push)
• Desapilar: se elimina el elemento frontal de la pila.(pop)
• Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)
• Vacía: devuelve cierto si la pila está vacía o falso en caso contrario.

LINK

http://es.kioskea.net/faq/2842-la-lista-enlazada-simple

Ejercicio de Lista

package Unidad_2;
import java.util.*;
public class ListaLigada {
    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 listas");
            System.out.println("1.- Incerta al principio");
            System.out.println("2.- Incerta al final");
            System.out.println("3.- Borrar al principio");
            System.out.println("4.- Borrar al final ");
            System.out.println("5.- Mostrar la lista ");
            System.out.println("6.- Borrar toda la lista");
            System.out.println("7.- Salir");
            System.out.println("\n");
            System.out.println("Elija la operacion que desee");
            op=leer.nextInt();
            switch (op){
            case 1:
                System.out.println("Inserte numero");
                num=leer.nextInt();
                lista.addFirst(num);
                break;
             case 2:
                 System.out.println("inserte numero");
                 num=leer.nextInt();
                 lista.addLast(num);
                 break;
             case 3:
                 System.out.println("Borra el primer nodo");
                 lista.removeFirst();
                 break;
             case 4:
                 System.out.println("Se borrara el nodo final");
                 lista.removeLast();
                 break;
             case 5:
                 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()+"");
                 }
             case 6:
                 System.out.println("Se borraran todos los elementos");
                 lista.clear();
                 break;
             case 7:
                 System.out.println("Al rato");
                 break;
            }
        }
       while (op !=7);
    }
}