2 ED Lineales

Estructuras de Datos Lineales
Dra. Laura Cruz Reyes

Instituto Tecnolgico de Ciudad Madero
Mxico
U1. Estructuras de datos lineales
Tipo de Dato abstracto (TDA)

Abstract Data Type (ADT)
Un TDA especifica un conjunto de datos y
las operaciones que operan sobre los datos.
Es abstracto en el sentido que es
independiente de la implementacin.
Permite conocer qu cualidades tiene, pero
no cmo estn implementadas
ADT= Operaciones + Estructura datos
Tipos de Estructuras de Datos

Almacenamiento
Contiguo
Lineales
Estructuras
de Datos
Almacenamiento
No Contiguo
No lineales
Almacenamiento de datos en Listas Lineales

1. Utilizando Arreglos: La relacin lineal esta
implcita en la relacin fsica de los elementos.
Desventaja: Almacenamiento esttico y tamao fijo.
Enith
0
Adrian
Omar
Pedro
2. Utilizando elementos de enlace: Agrega a cada

elemento un campo de enlace, no requieren
almacenamiento contiguo en memoria, se pueden
aadir y borrar elementos fcilmente.
Enith
Adrian
55
10
Omar
200
Pedro
38
En lenguajes donde no se cuenta con memoria

dinmica, las listas encadenadas se
implementan usando arreglos.
informacin
0
enlace
Pan
-1
Galletas
Jamn
Leche
inicio
El arreglo contiene dos

campos: uno para la
informacin y otro para
relacionar al siguiente
elemento.
3
4
5
6
7
La lista se recorre desde el

inicio y hasta encontrar un
elemento que contenga un
enlace vaco.
Estructuras Lineales
1. Pilas
2. Colas
3. Listas enlazadas
1. Simples
2. Dobles
3. Circulares
Operaciones Bsicas en Estructuras

Lineales
1.
Recorrido: Procesa cada elemento de la estructura.
2.
Bsqueda: Recupera la posicin de un elemento especfico.
3.
Insercin: Adiciona un nuevo elemento a la estructura.
4.
Borrado: Elimina un elemento de la estructura.
5.
Ordenacin: Ordena los elementos de la estructura de

acuerdo a los valores que contiene.
6.
Mezcla: Combina 2 estructuras en una sola.
PILAS
Definicin:
Estructura de datos lineal donde los elementos
pueden ser aadidos o removidos slo por un
extremo.
Trabajan con filosofa LIFO (Last In- First Out ).
Ejemplos:
Pila de libros
Pila de llamadas a funciones
Pila de recursion
Pila de resultados parciales de formulas aritmticas
OPERACIONES BASICAS CON

PILAS
-push (apilar).- Agrega un elementos a la pila en el
extremo llamado top.
-pop (desapilar).- Remueve el elemento de la pila que
se encuentra en el extremo llamado top.
-isEmpty (estaVacia).- Indica si la pila contiene o no
contiene elementos.
-top (cima).- Regresa el elemento de la pila que se
encuentra en el extremo llamado top.
REPRESENTACIN DE PILAS
Usando arreglos: Define un arreglo de una
dimensin (vector) donde se almacenan los
elementos.
TOP: Apunta hacia el elemento que se

encuentra en el extremo de la pila.
(inicialmente es -1).
Ejemplo
Insertar
Insertar
Insertar
Eliminar
A:
B:
C:
elemento
Inicio:
C
A
Top
-1
Top
Top
Top
Top
Implementacin de Pilas con Arreglos

Operacin
bsica
push( )
Funcin
pop( )
quitar elemento del tope
top( )
Recuperar elemento del

tope
Recuperar y quitar
elemento
Verificar si la pila tiene
elementos
Vaciar la pila
topAndPop()
isEmpty()
makeEmpty()
Guardar elemento en el tope
doubleArray()* Doblar el tamao de la pila

*Es operacin auxiliar
Interfaz para una pila de datos genrica

package DataStructures;
public interface Stack
//Pila
{
void push( Object x ); //apilar
void pop( ) throws UnderflowException;
Object top( ) throws UnderflowException;
//desapilar con verif. de desbordamiento inferior

//cima
Object topAndPop( ) throws UnderflowException; //cimaYDesapilar

boolean isEmpty( );
//esVacia
void makeEmpty( ); //vaciar

}
Implementacin usando un arreglo de objetos

public class ArrayStack implements Stack //PilaVec

{
.
public void pop( ) throws UnderflowException
{
if( isEmpty( ) )
throw new UnderflowException( "pop" );
topOfStack--;
}
public void push( Object x )
{
if( topOfStack + 1 == theArray.length )
doubleArray( );
theArray[ ++topOfStack ] = x;
}
private Object [ ] theArray;
private int
topOfStack;
private static final int DEFAULT_CAPACITY = 10;
}
public class UnderflowException

extends RuntimeException
{
public
UnderflowException(String
message)
{
super( message );
}
}

public Object topAndPop( ) throws UnderflowException

{}
public class ArrayStack implements Stack //PilaVec

{
public ArrayStack( ) //constructor
{
theArray = new Object[ DEFAULT_CAPACITY ];
topOfStack = -1;
}
public void push( Object x )

{}
private void doubleArray( ) //duplicarArreglo
{
Object [ ] newArray;
public boolean isEmpty( )

{ . }
newArray = new Object[ theArray.length * 2 ];

for( int i = 0; i < theArray.length; i++ )
newArray[ i ] = theArray[ i ];
theArray = newArray;
public void makeEmpty( )

{ }
}
private Object [ ] theArray;
private int
topOfStack;
public Object top( ) throws UnderflowException

{ . }
public void pop( ) throws UnderflowException
{}

import DataStructures.*;
//Test program to stack structure
public final class TestPila
{
public static void main (String [ ] args)
{
Stack p = new ArrayStack( );
for (int i= 0; i<5; i++)
p.push ( new Integer (i));
System.out.print ("Contenido:");
try
{
for (; ;)
System.out.print (" " + p.topAndPop( ));
}
catch (UnderflowException e){}
System.out.println ( );
}
}
Implementacin de Pilas con Arreglos

Operacin
bsica
push( )
Funcin
Guardar elemento en el tope
O(1)
pop( )
quitar elemento del tope
O(1)
top( )

tope
Recuperar y quitar
elemento
Verificar si la pila tiene
elementos
Vaciar la pila
O(1)
topAndPop()
isEmpty()
makeEmpty()
doubleArray()* Doblar el tamao de la pila

Complejidad
O(1)
O(1)
O(1)
O(n)
Implementacin usando la clase Vector

public class Stack {
private Vector items;
public Stack() {
items = new Vector(10);
}
public Object pop() { //non-synchronized

//public synchronized Object pop(){
int len = items.size();
Object obj = null;
if (len == 0) throw new EmptyStackException();
obj = items.elementAt(len-1);
items.removeElementAt(len 1);
return obj;
}
public push(Object item) {//non-synchronized

// public synchronized Object push(Object item){
items.addElement(item);
return item;
}
public boolean isEmpty() {
if (items.size == 0) return true;
else return false;
}
}
Aplicaciones de Pilas
Verificacin de balanceo de smbolos
EXPRESIONES ARITMETICAS:
Una expresin aritmtica contiene constantes, variables
y operaciones con distintos niveles de precedencia.
OPERACIONES :
^ potencia
*/ multiplicacin, divisin
+,- suma, resta
Notaciones Aritmticas
NOTACION INFIJA
Los operadores aparecen en medio de los operandos.
A + B, A 1, E/F, A * C , A ^ B , A + B + C, A+B-C
NOTACION PREFIJA
El operador aparece antes de los operandos.
+ AB, - A1, /EF, *AC, ^AB, ++ABC, -+ABC
NOTACION POSTFIJA
El operador aparece al final de los operandos.
AB+, A1-, EF/, AC*, AB^, AB+C+, AB+CDra. Laura Cruz Reyes
PASOS PARA EVALUAR UNA

EXPRESION
1. CONVERTIR A POSTFIJO: convertir la
expresin en notacin infijo a notacin postfijo
2. EVALUAR LA EXPRESION POSTFIJA: usar
una pila para mantener los resultados intermedios
cuando se evala la expresin en notacin posfijo.
REGLAS PARA CONVERTIR EXPRESION

INFIJA A POSTFIJA
Se crea un string resultado donde se almacena la expresin en postfijo.

1.- Los operandos se agregan directamente al resultado
2.- Un parntesis izquierdo se mete a la pila y tiene prioridad o precedencia
cero (0).
3.- Un parntesis derecho saca los elementos de la pila y los agrega al
resultado hasta sacar un parntesis izquierdo.
4.- Los operadores se insertan o sacan de la pila segn el condicin.
a) Si pila vaca entonces insertar operador actual.
b) Si el operador en el tope de pila tiene menor precedencia que el actual
entonces insertar operador actual.
c) Si el operador en el tope tiene mayor precedencia que el actual, entonces
sacar para agregar al resultado. La operacin se repite hasta encontrar
un operador con menor precedencia o la pila este vaca. El operador
actual se inserta en la pila.
5.- Cuando se termina de procesar la cadena que contiene la expresin infijo se
vaca la pila pasando los elementos al resultado.
Precedencia de operadores
idnticos
Expresin
Infijo
Expresin
Posfijo
Precedencia
El carcter + de la entrada tiene menor precedencia que el de la pila

El carcter de la entrada tiene menor precedencia que el de la pila
Ejemplos: infijo a posfijo
Ejemplos: infijo a postfijo

Convertir las siguientes expresiones infijas
a postfijo
A +B*C-D
A * ((B-C) / 2)
((X-Z)*(Y+W))/X+Y
Ejemplos: infijo a posfijo

Convertir las siguientes expresiones infijas a
posfijo
A +B*C-D ABC*+DA * ((B-C) / 2) ABC- 2 / *
((X-Z)*(Y+W))/X+Y XZ-YW+*X/Y+
Bosquejo de un Algoritmo para

EVALUAR UNA EXPRESION POSTFIJA
Recorrer la expresion de izquierda a derecha
1. Si es un operando
1. almacenar el valor en la pila de valores
2. Si es un operador:
1. Obtener dos operandos de la pila de valores
2. Aplicar el operador
3. Almacenar el resultado en la pila de valores
Al finalizar el recorrido, el resultado estar en la pila de valores
Evaluacin de una expresin posfijo
Funciones Recursivas
Las pilas pueden ser usadas para implementar la
recursin en programas.
Una funcin o procedimiento recursivo es aquel
que se llama a si mismo.
Ejemplos:
Factorial
Nmeros de Fibonacci
Torres de Hanoi
Algoritmos de Ordenamiento de datos
Recursion
// Funcion factorial
public static int factorial(int n) {
if (n<=1) return 1;
else return n*factorial(n-1);
}
Recursion
// Funcion fibonacci
public static int fib(int n) {
if (n==1) return 0;
else if (n==2) return 1;
else return fib(n-1)+fib(n-2);
}
Control de secuencia de programas.
Las pilas son requeridas para implementar

el control de flujo de ejecucin de un
programa con subprogramas (funciones,
procedimientos o mtodos).
Subprogramas recursivos o no recursivos
Existen llamadas a ejecucin de subprogramas.
Un subprograma se ejecuta completamente
antes de retornar al punto donde fue llamado.
Control de secuencia de programas.
// Programa Principal
class Principal{
public static void proceso1(){
System.out.println(proceso1);
proceso2();
}
public static void proceso2(){
System.out.println(proceso2);
}
public static void main(String[] args){
proceso1();
proceso2();
}Dra. Laura Cruz Reyes

}
Cual es la
salida de este
programa?
Clase Stack en Java

La clase Stack representa una pila de objetos donde el ltimo
en entrar es el primero en salir (LIFO). Extiende la clase
Vector con 5 operaciones bsicas.
java.util
Class Stack<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.Vector<E>
java.util.Stack<E>
All Implemented Interfaces:
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
Method Summary
bool empty()
ean
Tests if this stack is empty.
E peek()
Looks at the object at the top of this stack without removing it
from the stack.
E pop()
Removes the object at the top of this stack and returns that
object as the value of this function.
E push(E item)
Pushes an item onto the top of this stack.
int search(Object o)
Returns the 1-based position where an object is on this stack.
COLAS
Definicion. Es una lista lineal de elementos en la que las
operaciones de insertar y eliminar se realizan en diferentes
extremos de la cola.
Trabajan con filosofa FIFO ( First In - First out), el primer
elemento en entrar es el primer elemento en salir.
Ejemplos:
Cola de automviles esperando servicio en una gasolinera
Cola de clientes en una ventanilla del banco para pagar un servicio
Cola de programas en espera de ser ejecutados por una computadora.
TIPOS DE COLAS
Cola simple: Estructura lineal donde los elementos salen en
el mismo orden en que llegan.
Cola circular: Representacin lgica de una cola simple en un
arreglo.
Cola de Prioridades: Estructura lineal en la cual los
elementos se insertan en una posicin de la cola, tal que
conserve una relacin de mayor a menor prioridad, y se
remueven solamente por el frente.
Cola Doble (Bicola): Estructura lineal en la que los elementos
se pueden aadir o quitar por cualquier extremo de la cola
(cola bidireccional).
Operaciones bsicas en Colas Simples

enqueue (Insertar). Almacena al final de la cola el elemento
que se recibe como paramtro.
dequeue (eliminar). Saca de la cola el elemento que se
encuentra al frente.
isEmpty (estaVaca). Regresa un valor booleano indicando si
la cola tiene o no elementos (true si la cola esta vacia,
false si la cola tiene al menos un elemento).
Estado de la cola:
Operaciones:
Inicio: Cola Vaca

1. enqueue A (insertar A)
2. enqueue B (insertar B)
3. enqueue C (insertar C)
4. dequeue
(eliminar)
5. enqueue D (insertar D)
6. dequeue
(eliminar)
Implementacin de Colas
Arreglo
con frente fijo.
con frente movible.
circular.
Listas ligadas
Representacin usando arreglos

Las colas pueden ser representadas en arreglos de
una dimensin (vector) manteniendo dos variables
que indiquen el FRENTE (front) y FINAL (back)
de los elementos de la cola.
0
front (frente)
back (final)
Cuando la cola esta vaca las variables delimitadoras se

fijan a front = 0 y back =-1 y no es posible remover
elementos.
Cuando la cola esta llena ( front = 0 y back = n-1) no

es posible insertar elementos nuevos a la cola.
Cuando se remueven elementos el front puede

incrementarse para apuntar al siguiente elemento de la
cola (implementacin con frente mvil) o los elementos
en la cola pueden desplazarse una posicin adelante
(implementacin con frente fijo)
Recuperacin de espacio: En la implementacin con

frente movil, cuando no hay espacios libres al final del
arreglo los elementos pueden ser desplazados para
desocupar posiciones en un extremo del arreglo o se
puede manejar una estructura circular.
Ejemplo: Suponer que usamos un arreglo de 5

posiciones. Usando la representacin de frente fijo y
frente movible.
front
A B C
back
Al remover un elemento:
front
back
front
B C
Frente fijo
back
C
Frente movible
front
back
front
B C
back
Insertar elemento D:
front
back
front
B C D
Frente fijo
back
C D
Frente movible
Insertar elemento E:
back
front
front
B C D E
back
C D E
Insertar elemento F:
back
front
front
B C D
B C D E
Frente fijo
Frente movible
Insertar elemento G:
back
Cola llena!!!!
a) Generar Error
U1. Estructuras de datos

b)lineales
Duplicar
el tamao del vector
front
Cola Circular
Cola
inicial
back
B C D
front
Es una representacin
lgica de la cola en
un arreglo.
El front y back son
movibles.
Cuando el front o back
llegan al extremo se
regresan a la primera
posicin del arreglo.
Remover
back
C D
front
back
Insertar E
C D
back
front
Insertar F
C D
front
Cola Circular
back
front
2
D
C D
E
4
0
back
Aritmtica modular:
a) if (++back == theArray.length) back = 0;
b) (++back) % theArray.length
//operador mdulo
Representacin de colas:
Usando memoria esttica: arreglos con tamao fijo y
frente fijo o movible o representacin circular.
back
front
B C D
Usando memoria dinmica: Listas ligadas. back

B
8
front
D
2
E
300
F
1
40
Implementacin de Cola Circular con

Arreglos
Operacin bsica Funcin
enqueue( )
Inserta elemento por el frente

de la cola
quitar el elemento ubicado en
la parte trasera de la cola
Recuperar elemento del frente
dequeue( )
getfront( )
isEmpty()
makeEmpty()
Verificar si la cola tiene

elementos
Vaciar la cola
doubleArray()*
Doblar el tamao de la cola

Interfaz para una cola genrica

public interface Queue
{
void enqueue (Object x);
Object getFront ();
//
Object dequeue ();
boolean isEmpty ();
void makeEmpty ();
}
Implementacin de una cola circular usando el tipo Object

public Object dequeue ()

{ }
public class ArrayQueue implements Queue

{
private Object [] theArray;
private int currentSize;
private int front;
private int back;
public ArrayQueue ()
//Construct the queue.
{ theArray = new Object[DEFAULT_CAPACITY];
makeEmpty ();
}
// Return true if queue is empty, false otherwise.
public boolean isEmpty ()
{. }
public void enqueue (Object x)

{. }
public Object getFront ()
{.}
private int increment (int x)
{. }
//Make the queue logically
public void makeEmpty () empty.
{. }
private void doubleQueue ()
{. }
}
Implementacin de una cola circular usando Object

{. }

{ }

{
if (currentSize == theArray.length)
doubleQueue ();
back = increment (back);
theArray [back] = x;
currentSize++;
}
// Return and remove the least recently inserted item

//Throws UnderflowException if the queue is empty.

{
if (isEmpty ())
throw new UnderflowException ("ArrayQueue
dequeue");
currentSize--;
Object returnValue = theArray [front];
front = increment (front);
return returnValue;
}
//Get the first inserted item.

//Throws UnderflowException if empty.

{. }

{.}
//Get the first inserted item
//Throws UnderflowException if empty.
{
if (isEmpty ())
throw new UnderflowException
("ArrayQueue getFront");
return theArray [front];
}

{
if (++x == theArray.length)
x = 0;
return x;
}
//Make the queue logically

public void makeEmpty () empty.
{. }
//Make the queue logically empty.

public void makeEmpty ()
{
currentSize = 0;
front = 0;
back = -1;
}
// True if queue is empty, false otherwise.

{. }
// Return true if queue is empty, false

otherwise.
{
return currentSize == 0;
}

/

{. }
//Internal method to expand theArray.
{
Object [] newArray;
newArray = new Object [theArray.length * 2];
// Copy elements that are logically in the queue
for (int i = 0 ; i < currentSize ; i++,
front = increment (front))
newArray [i] = theArray [front];
theArray = newArray;
front = 0;
back = currentSize - 1;
}
Implementacin de una cola circular usando el tipo generics
public interface Queue <E> {
public boolean isEmpty ();
public void makeEmpty ();
public Edequeue ();
public E getFront ();
public void enqueue (E x)
}
Implementacin de una cola circular usando el tipo generics

public class ArrayQueue <E> T
implements Queue<<E> {
private E[] theArray;
private int currentSize;
private int front;
private int back;
private static final int
DEFAULT_CAPACITY = 10;
//Construct the queue.

public ArrayQueue ()
{. }

{. }
public void makeEmpty ()
{. }
public E dequeue ()
{. }
public E getFront ()
{. }
public void enqueue (E x)
{. }
{. }
{. }
Implementacin de Cola Circular con

Arreglos
Operacin
bsica
enqueue( )
Funcin
Complejidad
Inserta elemento por el

frente de la cola
quitar el elemento ubicado
en la parte trasera de a cola
frente
Verificar si la cola tiene
elementos
Vaciar la cola
O(1)
doubleArray()* Doblar el tamao de la cola
O(n)
dequeue( )
getfront( )
isEmpty()
makeEmpty()

O(1)
O(1)
O(1)
O(1)
Colas en Java
Java contiene la definicin de interfaces y
clases para el manejo de colas.
Las colas son una coleccin de elementos
diseadas para almacenar elementos que
esperan ser procesados.
Java contiene una interfase parametrizada
Queue<E> y varias clases que que la
implementan, entre ellas PriorityQueue<E>
Colas en Java
public interface Queue<E> extends
Collection<E> {
E element();
boolean offer(E o);
E peek();
E poll();
E remove();
}
Method Summary
E element()
Retrieves, but does not remove, the head of this queue, it throws an exception if this
queue is empty..
bool offer(E o)
ean
Inserts the specified element into this queue, if possible.
E
peek()
Retrieves, but does not remove, the head of this queue, returning null if this queue is
empty.
poll()
Retrieves and removes the head of this queue, or null if this queue is empty.
E remove()
Retrieves and removes the head of this queue.
LISTAS ENLAZADAS
Una lista es una coleccin lineal de elementos donde el orden de
los mismos se establece mediante enlaces.
LISTAS ENLAZADAS
1. Simples (con enlace simple)
2. Dobles (con enlace doble)
3. Circulares (el ltimo enlaza al primero)
4. Listas con iteradores (desplazador entre elementos)
LISTAS ENLAZADAS SIMPLES

Existe un elemento llamado header que apunta al primer
elemento de la lista. Al principio header apunta a null
Cada nodo contiene un campo de enlace next que apunta al
siguiente elemento.
El ltimo elemento de la lista en su campo next apunta a null.
*Lista enlazada de 0 elementos
header
element
header
Enith
next
Adrian
Omar
* Lista enlazada de 4 elementos

Pedro
LISTAS ENLAZADAS SIMPLES

Opcionalmente puede existir un elemento llamado tailer que
apunta al ultimo elemento de la lista.
Al principio tailer apunta a null
*Lista enlazada de 0 elementos
header
tailer
tailer
element
header
Enith
next
Adrian
Omar
* Lista enlazada de 4 elementos

Pedro
Operaciones con Listas Simples
AddFirst: Agrega un elemento al principio de la lista.

AddLast: Agrega un elemento al final de la lista.
removeFirst: Retira el primer elemento de la lista
removeLast: Retira el primer elemento de la lista
tailer
header
Enith
Adrian
Omar
Pedro
Los nodos de las listas simples

Un nodo se divide en 2 partes:
element: Contiene la informacin del elemento.
next: Contiene la direccin del siguiente nodo de la lista.
element
Node
next
public class Node{

// atributos
private Object element;
private Node next;
// el constructor de nodos
public Node (Object e, Node n){
element = e;
next = n;
}
}
Los nodos de las listas simples

Un nodo se divide en 2 partes:
element: Contiene la informacin del elemento.
next: Contiene la direccin del siguiente nodo de la lista.
element
Node
next
public class Node<E>{

// atributos
private E element;
private Node<E> next;
public Node (E e, Node<E> n){
element = e;
next = n;
}
}
Implementacin de la clase Node

public class Node{
// atributos
private Node next;
public Node (Object e, Node n){
element = e;
next = n;
}
public class Node <E>{

private E element;
private Node next;
public Node(E e, Node n){
element=e;
next=n;
}
Public Object getElement()

{return element;}
public void setElement(E e)

{element=e;}
Public Node getNext()

{return next;}
public void setNext(Node n)

{next=n;}
Public Object setElement(Object newElement)

{element = newElement;}
public E getElement()
{ return element;}
Public Node setNext(Node newNext)

{next = newNext;}
}
public Node getNext()

{ return next;}
}
Implementacin de una Lista Encadenada Simple

public class SLinkedList {
public class SLinkedList<E>{
public SLinkedList() {
header = null;
tailer = null;
size = 0;
}
public SLinkedList() {
header = null;
tailer = null;
size = 0;
}
// update and search methods would go here
// update and search methods would go here
protected Node header;

protected Node tailer
protected long size;
protected Node<E> header;

protected Node<E> tailer
protected long size;
LISTAS ENLAZADAS CON CABECERA

Es una lista enlazada que contiene un nodo especial llamado
nodo cabecera (nodo de sacrificio) que se encuentra al
inicio (y opcionalmente al final) de la misma.
Un NODO CABECERA es un nodo especial que no contiene
informacin, solo se utiliza para indicar el inicio/fin de los elementos
de la lista.
La utilizacin de un nodo cabecera en listas enlazadas

permiten que la implementacin de los mtodos de insercin
y eliminacin sea ms sencilla, ya que evitan tratar de
forma explcita los casos especiales (insertar al inicio o
eliminar el primer elemento). Sin embargo, requieren de un
nodo extra en la lista (el nodo cabecera).
TIPOS DE LISTA ENLAZADA CON

CABECERA:
1)LISTA SIMPLE CON CABECERA Y TIERRA
Es una lista enlazada con cabecera, donde el apuntador
del ltimo nodo contiene nulo.
2)LISTA CIRCULAR CON CABECERA
Es una lista enlazada con cabecera, donde el ltimo
nodo contiene un apuntador hacia la cabecera.
2)LISTA DOBLE CON CABECERA
Es una lista enlazada con cabecera, donde cada nodo
contiene un apuntador a los nodos siguiente y previo.
Representacin
1. Lista simple c/cabecera y tierra:
header
Nodo cabecera
2. Lista circular c/cabecera:

Nodo cabecera
header
Representacin
3. Lista doble c/cabecera:
header
tailer
LISTAS DOBLES
En una lista doble cada node (Node) contiene dos campos de
enlace: uno al elemento anterior (prev) y otro al elemento
siguiente (next) de la lista.
Estructura del Nodo:

prev
element
next
public class DNode{

// atributos
private Node next;
private Node prev;
public DNode (Object e, Node n, Node p){
element = e;
next = n;
prev=p;
}
}
LISTAS DOBLES
En una lista doble cada node (Node) contiene dos campos de
enlace: uno al elemento anterior (prev) y otro al elemento
siguiente (next) de la lista.
Estructura del Nodo:

prev
element
next
public class Dnode <E> {

// atributos
private E element;
private Node next;
private Node prev;
public DNode (E e, Node n, Node p){
element = e;
next = n;
prev=p;
}
}
Ejemplos sin cabecera
Lista Vaca
header = tailer =
Lista con un solo elemento

header
A
tailer
Lista con tres elementos

header
C
tailer
Ejemplos con cabecera

Lista Vaca
header
tailer
Lista con tres elementos

A
header
tailer
Iteradores
Patrn de diseo abstracto para desplazarse en una
coleccin de elementos, uno a la vez.
Encapsula el concepto de lugar y siguiente
hasNext()-verifica si existe un siguiente elemento
next()-recupera el elemento actual y se desplaza al siguiente
Iteradores de java
java.util.iterator : interfaz para iteradores
java.util.scanner: clase que implementa iteradores para
lectura de datos
Implementacin de Iteradores
1. Utilizando operaciones bsicas de listas
2. Hacienda pblica la clase Node
3. Con un arreglo de iteradores declarados en
la clase lista
4. Con una clase iterador
Con operaciones bsicas de listas: costosa
main
//copiar elementos de la lista lst a un arreglo---O(n)
for i=1 to lst.size()
e[i]= lst.getLast()
lst.removeLast()
lst.addFirst(e)
//next----------------------------------------------O(1)
return e[i++]
//hasNext------------------------------------------O(1)
return i> lst.size()
Haciendo pblica la clase nodo: no encapsula
main
LinkedList <String> lst = new DlinkesList <String> ( );
DNode p= new DNode(null, null. null);
p=lst.Zeroth();
while(lst.hasNext(p)){
s +=lst.Next(p) ;
if (lst.hasNext(p);
s +=,;
}
System.out.println (s)
Con un arreglo de iteradores declarados
en la clase lista: desperdicio de memoria
public class DLinkedList<E>
implements LinkedList<E> {
private DNode<E> header;
private DNode<E> tailer;
private DNode<E> [ ] iter;
privated int size;
public void hasNext(int i)
{..}
..
Main
LinkedList <String> lst =
new DLinkesList <String> ( );
while(lst.hasNext(1)){
s +=lst.Next(1) ;
if (lst.hasNext(1);
s +=,;
}
System.out.println (s);
}
Con una clase iteradora: diseo abstracto eficiente O(1)
public class DLinkedList<E>{
public DLinkedListIterator<E> iterator( ){
return new
LinkedListIterator<E>( header);
private class DLinkedListIterator<E>{

DNode current;
public LinkedListIterator (DNode n) {
{ current= n; }
private static class DNode <E>{]

}
Main
..
LinkedList <String> lst =
new DLinkesList <String> ( );
DLinkedListIterator<String> itr=lst.iterator( );
while(it.hasNext()){
s +=it.Next() ;
if (it.hasNext();
s +=,;
}
System.out.println (s);
..
Implementacin de Lista Encadenadas

operaciones con el iterador
nodo publico
add(p,e )
Iterador *
(nodo privado)
add(e )
hasNext(p )
hasNext( )
hasPrevious (p)
hasPrevious ()
previous(p)
previous()
next(p)
next()
nextIndex()
Funcin
Complejidad
Agrega el elemento e en la posicin actual
O(1)
O(1)
nextIndex()
Verifica si existe un elemente despus de la

posicin actual
Verifica si existe un elemente previo a la posicin
actual
Regresa el elemento e anterior a la posicin
actual y fija esa posicin como la actual
Regresa el elemento e posterior a la posicin
actual y fija esa posicin como la actual
Regresa el ndice del siguiente elemento
previousIndex()
previousIndex()
Regresa el ndice del elemento previo
O(n)
set(p,e)
set(e)
O(1)
remove(p)
Remove()
Reemplaza el elemento regresado por las

operaciones next o previous con e
Remueve el elemento regresado por las
operaciones next o previous con e
O(1)
O(1)
O(1)
O(n)
O(1)
Implementacin de Listas Encadenadas

operaciones con la lista
nodo publico
size(e )
Iterador *
(nodo privado)
size(e )
Funcin
Regresa el tamao de la lista
O(1)
isEmpty( )
isEmpty( )
Verifica si la lista est vaca
O(1)
get (i)
get (i)
Regresa el elemento en la posicin i
O(1)
set(i,e)
set(i,e)
Modifica el elemento en la posicin i con e
O(1)
add(i,e)
add(i,e)
Inserta el elemento e en la posicin i
O(1)
addFirst(e)
addFirst(e)
Inserta el elemento e en la primera posicin
O(1)
addLast()
addLast()
Inserta el elemento e en la ltima posicin
O(1)
*Operaciones sobre la lista
Complejidad
La interfase List de Java

java.util
Interface List<E>
All Superinterfaces:
Collection<E>, Iterable<E>
All Known Implementing Classes:

AbstractList, AbstractSequentialList, ArrayList,
AttributeList, CopyOnWriteArrayList, LinkedList,
RoleList, RoleUnresolvedList, Stack, Vector
La clase LinkedList en Java

java.util
Class LinkedList<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.AbstractSequentialList<E>
java.util.LinkedList<E>
Type Parameters:
E - the type of elements held in this collection
All Implemented Interfaces:
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, Queue<E>

2 ED Lineales

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

2 ED Lineales

Enviado por

Direitos autorais:

Formatos disponíveis

Estructuras de Datos Lineales

Dra. Laura Cruz Reyes

Dra. Laura Cruz Reyes

U1. Estructuras de datos lineales

Tipo de Dato abstracto (TDA)

U1. Estructuras de datos lineales

Tipos de Estructuras de Datos

Dra. Laura Cruz Reyes

U1. Estructuras de datos lineales

Almacenamiento de datos en Listas Lineales

2. Utilizando elementos de enlace: Agrega a cada

Dra. Laura Cruz Reyes

U1. Estructuras de datos lineales

En lenguajes donde no se cuenta con memoria

El arreglo contiene dos

Dra. Laura Cruz Reyes

La lista se recorre desde el

U1. Estructuras de datos lineales

Dra. Laura Cruz Reyes

U1. Estructuras de datos lineales

Operaciones Bsicas en Estructuras

Recorrido: Procesa cada elemento de la estructura.

Bsqueda: Recupera la posicin de un elemento especfico.

Insercin: Adiciona un nuevo elemento a la estructura.

Borrado: Elimina un elemento de la estructura.

Ordenacin: Ordena los elementos de la estructura de

Mezcla: Combina 2 estructuras en una sola.

Dra. Laura Cruz Reyes

U1. Estructuras de datos lineales

U1. Estructuras de datos lineales

OPERACIONES BASICAS CON

U1. Estructuras de datos lineales

TOP: Apunta hacia el elemento que se

Dra. Laura Cruz Reyes

U1. Estructuras de datos lineales

Dra. Laura Cruz Reyes

U1. Estructuras de datos lineales

Implementacin de Pilas con Arreglos

quitar elemento del tope

Recuperar elemento del

Guardar elemento en el tope

doubleArray()* Doblar el tamao de la pila

U1. Estructuras de datos lineales

Interfaz para una pila de datos genrica

//desapilar con verif. de desbordamiento inferior

Object topAndPop( ) throws UnderflowException; //cimaYDesapilar

void makeEmpty( ); //vaciar

U1. Estructuras de datos lineales

Implementacin usando un arreglo de objetos

public class ArrayStack implements Stack //PilaVec

Dra. Laura Cruz Reyes

public class UnderflowException

U1. Estructuras de datos lineales

Implementacin usando un arreglo de objetos

public Object topAndPop( ) throws UnderflowException

public class ArrayStack implements Stack //PilaVec

public void push( Object x )

public boolean isEmpty( )

newArray = new Object[ theArray.length * 2 ];

public void makeEmpty( )

public Object top( ) throws UnderflowException

Dra. Laura Cruz Reyes

U1. Estructuras de datos lineales

Implementacin usando un arreglo de objetos