03-Listas,Pilas y Colas

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()

{ return nElems; }//---------------------------------------------------------

5


public int find(double searchKey) {int lowerBound = 0;int upperBound = nElems-1;int curIn;while(true){

curIn = (lowerBound + upperBound ) / 2;if(a[curIn]==searchKey)

return curIn; // found itelse if(lowerBound > upperBound)

return nElems; // can't find itelse { // divide range

if(a[curIn] < searchKey)lowerBound = curIn + 1; // it's in upper half

elseupperBound = curIn - 1; // it's in lower half

} // end else divide range} // end while

} // end find()


public void insert(double value) // put element into array{int j;for(j=0; j<nElems; j++) // find where it goes

if(a[j] > value) // (linear search)break;

for(int k=nElems; k>j; k--) // move bigger ones upa[k] = a[k-1];

a[j] = value; // insert itnElems++; // increment size} // end insert()

6


public boolean delete(double value){int j = find(value);if(j==nElems) // can't find it

return false;else // found it

{for(int k=j; k<nElems; k++) // move bigger ones down

a[k] = a[k+1];nElems--; // decrement sizereturn true;}

} // end delete()


public void display() // displays array contents{for(int j=0; j<nElems; j++) // for each element,

System.out.print(a[j] + " "); // display itSystem.out.println("");}

//---------------------------------------------------------} // 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 );

}public LinkedListItr find( Object x )

{ListNode itr = header.next;while( itr != null && !itr.element.equals( x ) )

itr = itr.next;return new LinkedListItr( itr );

}

La clase La clase LinkedListLinkedList

public LinkedListItr findPrevious( Object x ){ListNode itr = header;while(itr.next != null && !itr.next.element.equals(x))

itr = itr.next;return new LinkedListItr( itr );

}public void remove( Object x )

{LinkedListItr p = findPrevious( x );if( p.current.next != null )

p.current.next = p.current.next.next;}

11

La clase La clase LinkedListLinkedList

public static void printList( LinkedList theList ){

if( theList.isEmpty( ) )System.out.print( "Empty list" );

else{

LinkedListItr itr = theList.first( );for( ; !itr.isPastEnd( ); itr.advance( ) )

System.out.print( itr.retrieve( ) + " " );}

System.out.println( );}

Listas doblemente encadenadasListas doblemente encadenadas

Una lista doblemente encadenada

A3 A4 A5A2A1

Una lista circular doblemente encadenada

A3 A4 A5A2A1

12

El ADT polinomioEl ADT polinomio

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];

return product;}

Polinomios usando arreglosPolinomios usando arreglos

public void print( ){

for( int i = highPower; i > 0; i-- )System.out.print( coeffArray[ i ] + "x^" + i + " + " );

System.out.println( coeffArray[ 0 ] );}

private int coeffArray[ ] = new int [ MAX_DEGREE + 1 ];private int highPower = 0;}

14

Polinomios usando listasPolinomios usando listas

100010 145 01

P1El polinomio 1510 141000 ++ xx

19903 1492-2 111 05

P2El polinomio 51123 14921990 ++− xxx

MultilistasMultilistasS1 S2 S3 S4

C1

C2

C3

C4

C5

15

Listas encadenadas usando Listas encadenadas usando cursorescursores

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;

}

17

CusorListCusorListpublic CursorList( )

{header = alloc( );cursorSpace[ header ].next = 0;


{return cursorSpace[ header ].next == 0;


{while( !isEmpty( ) )

remove( first( ).retrieve( ) );}

public CursorListItr zeroth( ){

return new CursorListItr( header );}

CusorListCusorListpublic CursorListItr first( )

{return new CursorListItr( cursorSpace[ header ].next );

}public void insert( Object x, CursorListItr p )

{if( p != null && p.current != 0 ){

int pos = p.current;int tmp = alloc( );cursorSpace[ tmp ].element = x;cursorSpace[ tmp ].next = cursorSpace[ pos ].next;cursorSpace[ pos ].next = tmp;

}}

18

CusorListCusorList

public CursorListItr find( Object x ){int itr = cursorSpace[ header ].next;while( itr != 0 && !cursorSpace[ itr].element.equals(x))

itr = cursorSpace[ itr ].next;return new CursorListItr( itr );

}public CursorListItr findPrevious( Object x )

{int itr = header;while( cursorSpace[ itr ].next != &&

!cursorSpace[cursorSpace[itr].next].element.equals(x))itr = cursorSpace[ itr ].next;

return new CursorListItr( itr );}

CusorListCusorListpublic void remove( Object x ) {

CursorListItr p = findPrevious( x );int pos = p.current;if( cursorSpace[ pos ].next != 0 ) {

int tmp = cursorSpace[ pos ].next;cursorSpace[ pos ].next = cursorSpace[ tmp ].next;free( tmp ); }

}static public void printList( CursorList theList ) {

if( theList.isEmpty( ) )System.out.print( "Empty list" );

else {CursorListItr itr = theList.first( );for( ; !itr.isPastEnd( ); itr.advance( ) )System.out.print( itr.retrieve( ) + " " ); }

System.out.println( );}

19

CusorListCusorListprivate int header;static CursorNode[ ] cursorSpace;private static final int SPACE_SIZE = 100;static{

cursorSpace = new CursorNode[ SPACE_SIZE ];for( int i = 0; i < SPACE_SIZE; i++ )

cursorSpace[ i ] = new CursorNode( null, i + 1 );cursorSpace[ SPACE_SIZE - 1 ].next = 0;

} public static void main( String [ ] args )

{CursorList theList = new CursorList( );CursorListItr theItr;int i;theItr = theList.zeroth( );printList( theList );

CusorListCusorListfor( i = 0; i < 10; i++ ){

theList.insert( new MyInteger( i ), theItr );printList( theList );theItr.advance( );

}

for( i = 0; i < 10; i += 2 )theList.remove( new MyInteger( i ) );

for( i = 0; i < 10; i++ )if(( i % 2 == 0 ) != (theList.find(

new MyInteger( i )).isPastEnd( )))System.out.println( "Find fails!" );

System.out.println( "Finished deletions" );printList( theList );

}}

20

El ADT Pila (El ADT Pila (StackStack))

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

{public StackLi( )

{topOfStack = null;

}public boolean isFull( )

{return false;


{return topOfStack == null;


{topOfStack = null;

}

Pilas usando listas encadenadasPilas usando listas encadenadaspublic Object top( )

{if( isEmpty( ) )

return null;return topOfStack.element;

}public void pop( ) throws Underflow {

if( isEmpty( ) )throw new Underflow( );

topOfStack = topOfStack.next;}

public Object topAndPop( ) {if( isEmpty( ) )

return null;Object topItem = topOfStack.element;topOfStack = topOfStack.next;return topItem;

}

22

Pilas usando listas encadenadasPilas usando listas encadenadaspublic void push( Object x )

{topOfStack = new ListNode( x, topOfStack );

}

private ListNode topOfStack;public static void main( String [ ] args )

{StackLi s = new StackLi( );

for( int i = 0; i < 10; i++ )s.push( new MyInteger( i ) );

while( !s.isEmpty( ) )System.out.println( s.topAndPop( ) );

} }

Pilas usando arreglosPilas usando arreglospublic class StackAr

{public StackAr( )

{this( DEFAULT_CAPACITY );

}public StackAr( int capacity )

{theArray = new Object[ capacity ];topOfStack = -1;


{return topOfStack == -1;

}public boolean isFull( )

{return topOfStack == theArray.length - 1;

}

23

Pilas usando arreglosPilas usando arreglospublic void makeEmpty( )

{topOfStack = -1;

}public Object top( )

{if( isEmpty( ) )

return null;return theArray[ topOfStack ];

}public void pop( ) throws Underflow

{if( isEmpty( ) )

throw new Underflow( );theArray[ topOfStack-- ] = null;

}

Pilas usando arreglosPilas usando arreglospublic void push( Object x ) throws Overflow

{if( isFull( ) )

throw new Overflow( );theArray[ ++topOfStack ] = x;

}public Object topAndPop( )

{if( isEmpty( ) )

return null;Object topItem = top( );theArray[ topOfStack-- ] = null;return topItem;

}

24

Pilas usando arreglosPilas usando arreglosprivate Object [ ] theArray;private int topOfStack;static final int DEFAULT_CAPACITY = 10;public static void main( String [ ] args ){

StackAr s = new StackAr( 12 );try{

for( int i = 0; i < 10; i++ )s.push( new MyInteger( i ) );

}catch( Overflow e ) { System.out.println(

"Unexpected overflow" ); }while( !s.isEmpty( ) )

System.out.println( s.topAndPop( ) );}

}

Aplicaciones de pilasAplicaciones de pilas

nn Balance de Balance de simbolossimbolos..nn ConversiConversióón de expresiones de n de expresiones de infixinfix a a

postfixpostfix..nn EvaluaciEvaluacióón de expresiones.n de expresiones.nn EliminaciEliminacióón de n de recursirecursióónn

25

Balance de Balance de ParentesisParentesisclass BracketChecker

{private String input; // input stringpublic BracketChecker(String in) // constructor

{ input = in; }public void check()

{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

{private StackX theStack;private String input;private String output = "";

public InToPost(String in) // constructor{input = in;int stackSize = input.length();theStack = new StackX(stackSize);}

Infix to PostfixInfix to Postfixpublic String doTrans() // do translation to postfix

{for(int j=0; j<input.length(); j++) // for each char

{char ch = input.charAt(j); // get itswitch(ch)

{case '+': // it's + or -case '-':

gotOper(ch, 1); // go pop operatorsbreak; // (precedence 1)

case '*': // it's * or /case '/':

gotOper(ch, 2); // go pop operatorsbreak; // (precedence 2)

case '(': // it's a left parentheStack.push(ch); // push itbreak;

27

Infix to PostfixInfix to Postfix

case ')': // it's a right parengotParen(); // go pop operatorsbreak;

default: // must be an operandoutput = output + ch; // write it to outputbreak;

} // end switch} // end for

while( !theStack.isEmpty() ) // pop remaining opers{output = output + theStack.pop(); // write to output

}return output; // return postfix

} // end doTrans()

Infix to PostfixInfix to Postfixprivate void gotOper(char opThis, int prec1)

{ // got operator from inputwhile( !theStack.isEmpty() )

{char opTop = theStack.pop();if( opTop == '(' ) // if it's a '('

{theStack.push(opTop); // restore '('break;}

else // it's an operator{int prec2; // precedence of new opif(opTop=='+' || opTop=='-') // find new op prec

prec2 = 1;else

prec2 = 2;

28


if(prec2 < prec1) // if prec of new op less{ // than prec of oldtheStack.push(opTop); // save newly-popped opbreak;}

else // prec of new not lessoutput = output + opTop; // than prec of old

} // end else (it's an operator)} // end while

theStack.push(opThis); // push new operator} // end gotOper()


private void gotParen(){ // got right paren from inputwhile( !theStack.isEmpty() )

{char chx = theStack.pop();if( chx == '(' ) // if popped '('

break; // we're doneelse // if popped operator

output = output + chx; // output it} // end while

} // end gotParen()} // end class InToPost

29

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

{public QueueAr( )

{this( DEFAULT_CAPACITY );

}public QueueAr( int capacity )

{theArray = new Object[ capacity ];makeEmpty( );


{return currentSize == 0;

}

32

Colas Usando ArreglosColas Usando Arreglospublic boolean isFull( )

{return currentSize == theArray.length;


{currentSize = 0;front = 0;back = -1;

}public Object getFront( )

{if( isEmpty( ) )

return null;return theArray[ front ];

}

Colas Usando ArreglosColas Usando Arreglospublic Object dequeue( )

{if( isEmpty( ) )

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

03-Listas,Pilas y Colas

Documents

Transcript of 03-Listas,Pilas y Colas