1 Estructuras de Datos y Estructuras de Datos y Algoritmos Algoritmos Listas, Pilas y Colas Listas, Pilas y Colas Contenido Contenido n Listas Listas n Tipos abstractos de datos ( Tipos abstractos de datos (ADTs ADTs) n El ADT lista El ADT lista n Implementaci Implementación usando arreglos n usando arreglos n Listas encadenadas Listas encadenadas n Aplicaciones Aplicaciones n Implementaci Implementación mediante cursores n mediante cursores n El ADT pila ( El ADT pila (Stack Stack) n Implementaci Implementación de pilas n de pilas n Aplicaciones Aplicaciones n El ADT cola El ADT cola n Implementaci Implementación de colas n de colas n Aplicaciones Aplicaciones
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
1
Estructuras de Datos y Estructuras de Datos y AlgoritmosAlgoritmos
Listas, Pilas y ColasListas, Pilas y Colas
ContenidoContenido
nn ListasListasnn Tipos abstractos de datos (Tipos abstractos de datos (ADTsADTs))nn El ADT listaEl ADT lista
nn ImplementaciImplementacióón usando arreglosn usando arreglosnn Listas encadenadasListas encadenadasnn AplicacionesAplicacionesnn ImplementaciImplementacióón mediante cursoresn mediante cursores
nn El ADT pila (El ADT pila (StackStack))nn ImplementaciImplementacióón de pilasn de pilasnn AplicacionesAplicaciones
nn El ADT colaEl ADT colann ImplementaciImplementacióón de colasn de colasnn AplicacionesAplicaciones
2
ContenidoContenido
nn Los puntos resaltantes de este capLos puntos resaltantes de este capíítulo tulo son:son:nn El concepto de Tipo de Dato Abstracto (ADT)El concepto de Tipo de Dato Abstracto (ADT)nn Como realizar operaciones eficientes en listasComo realizar operaciones eficientes en listasnn El ADT Pila y sus aplicacionesEl ADT Pila y sus aplicacionesnn Al ADT Cola y sus aplicacionesAl ADT Cola y sus aplicaciones
Tipos de Datos Abstractos (Tipos de Datos Abstractos (ADTsADTs))
nn Un ADT es un conjunto de objetos Un ADT es un conjunto de objetos acompaacompaññado de un conjunto de ado de un conjunto de operaciones definidas sobre ellos.operaciones definidas sobre ellos.
nn Los Los ADTsADTs son abstracciones matemson abstracciones matemááticas ticas independientes de la implementaciindependientes de la implementacióónn
nn Enteros, reales y Enteros, reales y booleanosbooleanos son son ATDsATDs asasíícomo lo son listas, pilas y colascomo lo son listas, pilas y colas
3
El ADT ListaEl ADT Lista
nn Las listas generalizadas tienen la forma ALas listas generalizadas tienen la forma A11, , AA22, A, A33, ... , ... AANN donde donde N N es el tamaes el tamañño de la o de la lista. Si lista. Si NN es cero la lista esta vaces cero la lista esta vacíía.a.
nn Para toda lista excepto la lista vacPara toda lista excepto la lista vacíía, a, AAii+1+1sigue a sigue a AAii. El primer elemento es A1 y el . El primer elemento es A1 y el úúltimo ltimo AANN
nn La posiciLa posicióón del elemento n del elemento AAii es es ii
Operaciones tOperaciones tíípicas en listaspicas en listas
nn printListprintList()(): imprimir la lista.: imprimir la lista.nn makeEmptymakeEmpty()(): crear una lista vac: crear una lista vacíía.a.nn pos pos find(elemfind(elem xx)): buscar la primera : buscar la primera
ocurrencia del elemento ocurrencia del elemento xx en la lista.en la lista.nn elemelem findKth(posfindKth(pos kk)): buscar el elemento en : buscar el elemento en
la posicila posicióón n kk..nn InsertInsert ((elemelem xx, , pospos kk)): insertar el elemento : insertar el elemento
xx en la posicien la posicióón n kk..nn Remove(elemRemove(elem xx): eliminar la primera ocurrencia ): eliminar la primera ocurrencia
del elemento del elemento xx..
4
Lista usando arreglosLista usando arreglos
nn Se de estimar el tamaSe de estimar el tamañño del arreglo, lo que o del arreglo, lo que puede resultar en un desperdicio de espacio.puede resultar en un desperdicio de espacio.
nn Las operaciones Las operaciones printListprintList, , findfind, , insertinsert y y removeremove son son O(NO(N), mientras que ), mientras que findKthfindKth es es O(1). (Si la lista esta ordenada por una clave O(1). (Si la lista esta ordenada por una clave comparable el tiempo de comparable el tiempo de findfind es es O(logO(log N)).N)).
nn Crear una lista mediante sucesivas inserciones Crear una lista mediante sucesivas inserciones es es O(NO(N22).).
Ejemplo: una lista ordenada de Ejemplo: una lista ordenada de nnúúmerosmeros
class OrdArray{private double[] a; // ref to array aprivate int nElems; // number of data items//---------------------------------------------------------public OrdArray(int max) // constructor
{a = new double[max]; // create arraynElems = 0;}
//---------------------------------------------------------public int size()
//---------------------------------------------------------} // end class OrdArray
7
Listas encadenadasListas encadenadas
nn A diferencia de los arreglos los elementos A diferencia de los arreglos los elementos no estno estáán almacenados en forma contigua.n almacenados en forma contigua.
nn Cada elemento, ademCada elemento, ademáás de la data, s de la data, contiene una referencia a la ubicacicontiene una referencia a la ubicacióón del n del prpróóximo elemento.ximo elemento.
nn Los tiempos para Los tiempos para insertinsert y y removeremove son son O(1), mientras que O(1), mientras que findfind y y findKthfindKthrequieren requieren O(NO(N).).
Operaciones en listas encadenadasOperaciones en listas encadenadas
A1 A2 A3 A4 A5
Una lista encadenada
A1 A2 A3 A4 A5
Borrando un elemento en una lista encadenada
A1 A2 A3 A4 A5
Agregando un elemento en una lista encadenada X
8
Cabeza de listaCabeza de lista
A1 A2 A3 A4
Una lista encadenada
Una lista vacía
header
header
Nodos de la listaNodos de la listapackage DataStructures;class ListNode
{// Constructors
ListNode( Object theElement ){
this( theElement, null );}ListNode( Object theElement, ListNode n ){
element = theElement;next = n;
}// Friendly data; accessible by other package routines
Object element;ListNode next;
}
9
IteradoresIteradores
public class LinkedListItr {LinkedListItr( ListNode theNode ) {
current = theNode;}
public boolean isPastEnd( ) {return current == null;
}public Object retrieve( ) {
return isPastEnd( ) ? null : current.element;}
public void advance( ) {if( !isPastEnd( ) )
current = current.next;}
private ListNode current; // Current position}
La clase La clase LinkedListLinkedListpublic class LinkedList {private ListNode header;public LinkedList( )
{header = new ListNode( null );
}public boolean isEmpty( )
{return header.next == null;
}public void makeEmpty( )
{header.next = null;
}public LinkedListItr zeroth( )
{return new LinkedListItr( header );
}
10
La clase La clase LinkedListLinkedListpublic LinkedListItr first( )
{return new LinkedListItr( header.next );
}public void insert( Object x, LinkedListItr p )
{if( p != null && p.current != null )
p.current.next = new ListNode( x, p.current.next );
nn Se definirSe definiráá un tipo de datos abstracto para un tipo de datos abstracto para representar polinomios de una variable de la representar polinomios de una variable de la forma:forma:
nn Se definen las operaciones para crear, Se definen las operaciones para crear, imprimir, sumar y multiplicar polinomios.imprimir, sumar y multiplicar polinomios.
nn Se podrSe podríían considerar otras operaciones como an considerar otras operaciones como diferenciacidiferenciacióón y divisin y divisióónn
∑=
=N
i
ii xaxf
0)(
Polinomios usando arreglosPolinomios usando arreglospublic class Polynomial
{public static final int MAX_DEGREE = 100;public static int max( int a, int b ){
return a > b ? a : b;}public Polynomial( ){
zeroPolynomial( );}public void zeroPolynomial( ){
for( int i = 0; i <= MAX_DEGREE; i++ )coeffArray[ i ] = 0;
highPower = 0;}
13
Polinomios usando arreglosPolinomios usando arreglospublic Polynomial add( Polynomial rhs ){Polynomial sum = new Polynomial( );sum.highPower = max( highPower, rhs.highPower );for( int i = sum.highPower; i >= 0; i-- )sum.coeffArray[i] = coeffArray[i] + rhs.coeffArray[i];
return sum;}
public Polynomial multiply( Polynomial rhs ) throws Overflow{Polynomial product = new Polynomial( );product.highPower = highPower + rhs.highPower;if( product.highPower > MAX_DEGREE )throw new Overflow( );
for( int i = 0; i <= highPower; i++ )for( int j = 0; j <= rhs.highPower; j++ )product.coeffArray[i+j]+=coeffArray[i]*rhs.coeffArray[j];
nn Se usa un arreglo para almacenar los nodos.Se usa un arreglo para almacenar los nodos.nn Deben simularse las caracterDeben simularse las caracteríísticas de las listas sticas de las listas
encadenadas:encadenadas:nn Cada nodo contiene un enlace al siguiente. En el caso Cada nodo contiene un enlace al siguiente. En el caso
de cursores los enlaces son de cursores los enlaces son ííndices del arreglondices del arreglonn Se pueden obtener nuevos nodos cuando se Se pueden obtener nuevos nodos cuando se
necesitan y los nodos son automnecesitan y los nodos son automááticamente reticamente re--usados usados al disponer de ellos.al disponer de ellos.
nn Esta implementaciEsta implementacióón puede hacerse en n puede hacerse en lenguajes que no manejan memoria dinlenguajes que no manejan memoria dináámica.mica.
Nodo para Nodo para CursorListCursorList
package DataStructures;class CursorNode
{// Constructors
CursorNode( Object theElement ){
this( theElement, 0 );}CursorNode( Object theElement, int n ){
element = theElement;next = n;
}// Friendly data; accessible by other package routines
Object element;int next;
}
16
IteradorIterador para para CursorListCursorList
public class CursorListItr {CursorListItr( int theNode ) {
current = theNode;}
public boolean isPastEnd( ) {return current == 0;
}public Object retrieve( ) {
return isPastEnd( ) ? null : CursorList.cursorSpace[ current ].element;
}public void advance( ) {
if( !isPastEnd( ) )current = CursorList.cursorSpace[ current ].next;
}int current; // Current position}
CusorListCusorListpublic class CursorList
{private static int alloc( ){
int p = cursorSpace[ 0 ].next;cursorSpace[ 0 ].next = cursorSpace[ p ].next;if( p == 0 )
throw new OutOfMemoryError( );return p;
}
private static void free( int p ){
cursorSpace[ p ].element = null;cursorSpace[ p ].next = cursorSpace[ 0 ].next;cursorSpace[ 0 ].next = p;
nn Una pila (Una pila (stackstack) es una lista en la que ) es una lista en la que todas las operaciones se efecttodas las operaciones se efectúúan en la an en la posiciposicióón final de la misman final de la misma
nn Las operaciones fundamentales son:Las operaciones fundamentales son:nn push(elempush(elem x): coloca el elemento x al final de x): coloca el elemento x al final de
la lista.la lista.nn pop(): remueve el elemento al final de la lista.pop(): remueve el elemento al final de la lista.nn elemelem toptop(): retorna el elemento final de la pila(): retorna el elemento final de la pila
El ADT Pila (El ADT Pila (StackStack))
nn Las pilas tambiLas pilas tambiéén se conocen como colas LIFO n se conocen como colas LIFO ((LastLast In In FirstFirst OutOut))
nn Debido a la simplicidad de las operaciones Debido a la simplicidad de las operaciones permitidas estas son muy rpermitidas estas son muy ráápidas.pidas.
nn A pesar de su simplicidad, las pilas son A pesar de su simplicidad, las pilas son estructuras muy estructuras muy úútiles.tiles.
nn Todos los programas tienen al menos una pila Todos los programas tienen al menos una pila para almacenar argumentos, variables locales y para almacenar argumentos, variables locales y direccidireccióón de retorno de llamadas a funciones.n de retorno de llamadas a funciones.
21
Pilas usando listas encadenadasPilas usando listas encadenadaspublic class StackLi
{int stackSize = input.length(); // get max stack sizeStackX theStack = new StackX(stackSize); // make stackfor(int j=0; j<input.length(); j++)// get chars in turn
{char ch = input.charAt(j); // get charswitch(ch)
{case '{': // opening symbolscase '[':case '(':
theStack.push(ch); // push thembreak;
case '}': // closing symbolscase ']':case ')':
if( !theStack.isEmpty()) // if stack not empty,{char chx = theStack.pop(); // pop and checkif( (ch=='}' && chx!='{') ||
(ch==']' && chx!='[') ||(ch==')' && chx!='(') )System.out.println("Error: "+ch+" at "+j);
}else // prematurely emptySystem.out.println("Error: "+ch+" at "+j);
break;default: // no action on other characters
break;} // end switch
} // end forif( !theStack.isEmpty() )
System.out.println("Error: missing right delimiter");} // end check()
} // end class BracketChecker
26
Infix to PostfixInfix to Postfixclass InToPost // infix to postfix conversion
EvaluaciEvaluacióón de una expresin de una expresióón n PostfixPostfixclass ParsePost
{private StackX theStack;private String input;
public ParsePost(String s){ input = s; }
public int doParse(){theStack = new StackX(20); // make new stackchar ch;int j;int num1, num2, interAns;for(j=0; j<input.length(); j++) // for each char,
{ch = input.charAt(j); // read from inputif(ch >= '0' && ch <= '9') // if it's a number
theStack.push( (int)(ch-'0') ); // push it
EvaluaciEvaluacióón de una expresin de una expresióón n PostfixPostfixelse // it's an operator
{num2 = theStack.pop(); // pop operandsnum1 = theStack.pop();switch(ch) // do arithmetic
{case '+':
interAns = num1 + num2;break;
case '-':interAns = num1 - num2;break;
case '*':interAns = num1 * num2;break;
case '/':interAns = num1 / num2;break;
30
EvaluaciEvaluacióón de una expresin de una expresióón n PostfixPostfixdefault:
interAns = 0;} // end switch
theStack.push(interAns); // push result} // end else
} // end forinterAns = theStack.pop(); // get answerreturn interAns;} // end doParse()
} // end class ParsePost
El ADT ColaEl ADT Cola
nn A semejanza de una pila, una cola es una A semejanza de una pila, una cola es una lista en la que se restringen las lista en la que se restringen las operaciones permitidas:operaciones permitidas:nn Solo se puede insertar en un extremo de la Solo se puede insertar en un extremo de la
lista.lista.nn Solo se permite extraer elementos en el Solo se permite extraer elementos en el otrootro
extremo de la lista.extremo de la lista.nn Cualquier implementaciCualquier implementacióón de lista es n de lista es
adecuada para colas.adecuada para colas.
31
Colas Usando ArreglosColas Usando Arreglos
nn Es posible implementar colas usando arreglos de Es posible implementar colas usando arreglos de modo que las operaciones requieren un tiempo modo que las operaciones requieren un tiempo O(1)O(1)
nn AdemAdemáás del arreglo se tienen dos variables que s del arreglo se tienen dos variables que contienen los contienen los ííndices al inicio y fin de la cola.ndices al inicio y fin de la cola.
nn TambiTambiéén se usa una tercera variable que n se usa una tercera variable que contiene la longitud de la cola para diferenciar contiene la longitud de la cola para diferenciar una cola vacuna cola vacíía de una que llena todo el arreglo.a de una que llena todo el arreglo.
Colas Usando ArreglosColas Usando Arreglospublic class QueueAr
return null;currentSize--;Object frontItem = theArray[ front ];theArray[ front ] = null;front = increment( front );return frontItem;
}public void enqueue( Object x ) throws Overflow
{if( isFull( ) )
throw new Overflow( );back = increment( back );theArray[ back ] = x;currentSize++;
}
33
Colas Usando ArreglosColas Usando Arreglosprivate int increment( int x )
{if( ++x == theArray.length )
x = 0;return x;
}
private Object [ ] theArray;private int currentSize;private int front;private int back;
static final int DEFAULT_CAPACITY = 10;}
Aplicaciones de ColasAplicaciones de Colas
nn Colas de impresiColas de impresióón.n.nn SimulaciSimulacióón de ln de lííneas de espera.neas de espera.nn Colas de acceso a archivos en servidoresColas de acceso a archivos en servidores