¡Descarga Apuntes sobre Pascal Parte2 y más Apuntes en PDF de Informática solo en Docsity!
AUX _PAC := AUX_MED ^. PROX ;
WHILE ( AUX_PAC <>NIL ) DO
BEGIN
C := C +1 ;
AUX_PAC := AUX_PAC ^. PROX ;
END ;
IF ( C > 10 ) THEN WRITELN ( AUX_MED ^. NOM_MED ) ;
AUX_MED := AUX_MED ^. SIG ;
END ;
EJER 14: Dada esta declaración de tipos y suponiendo que está cargada la estructuta hacer un algoritmo que acepte por teclado una palabra y la busque en la estructura, en caso de no encontrarla la inserta. TYPE PUNTERO = ^PALABRA; PALABRA = RECORD INFO : STRING; SIG : PUNTERO; END; VAR DICCIONARIO = ARRAY[`A'..'Z'] OF PUNTERO; PAL : STRING; AUX : PUNTERO; ENC : BOOLEAN; BEGIN READLN(PAL); AUX := DICCIONARIO[PAL[1]]; ENC := FALSO; WHILE (AUX<>NIL) AND (ENC=FALSO) DO
BEGIN
IF AUX^.INFO = PAL THEN
ENC := VERDAD
ELSE
AUX := AUX^.SIG;
END;
IF (ENC = FALSO) THEN
BEGIN
NEW(AUX);
AUX^.INFO := PAL;
AUX^.SIG := DICCIONARIO[PAL[1]];
DICCIONARIO[PAL[1]] := AUX;
END;
END;
'A'
'B'
'Z'
EJER 15: Se tiene un fichero PALABRAS.DAT cuya estructura es la siguiente: palabra1 Se desea almacenar al contenido del fich en una tabla de esta forma: palabra2 − cada palabra se almacenará en un nodo de una lista enlazada simple : cuyo puntero a comienzo se encuentra en la posición de la tabla palabraN correspondiente a la primera letra de dicha palabra (ver dibujo). Se pide: declarar la estructura y hacer la carga del fichero. árbol ala 'A' bueno 'B'
RESET (F);
WHILE NOT EOF(F) DO
BEGIN
READLN (F,REG);
NEW (AUX);
AUX^.CONTENIDO := REG;
AUX^.SIG := DICCIONARIO[REG[1]].SIG;
DICCIONARIO[REG[1]].SIG := AUX;
END;
CLOSE (F);
END;
EJER 16: Se desea almacenar en un vector el nombre de 15 universidades españolas. En forma dinámica de cada universidad dependen las facultades que la forman (solamente el nombre de la facultad). Además de cada facultad y también en forma dinámica dependen los cursos de los cuales se conoce su nº de alumnos. Se pide: − implementación de la estructura − suponiendo cargada la estructura hacer un algoritmo que visualice el nombre de las facultades de la universidad complutense de Madrid que tengan más de 1000 alumnos en primer curso. TYPE DIRECCION = ^CURSO; CURSO = RECORD NOMBRE : STRING; NUMERO : INTEGER; PROX : DIRECCION; END; PUNTERO = ^FACULTAD; FACULTAD = RECORD NOMBRE : STRIG;
PROX : DIRECCION;
SIG : PUNTERO;
END;
UNIVER = RECORD
NOMBRE : STRING;
SIG : PUNTERO;
END;
VECTOR = ARRAY[1..15] OF UNIVER;
VAR
UNIVERSIDAD : VECTOR;
AUX_FAC : PUNTERO;
AUX_CUR : DIRECCION;
BEGIN
I:=1;
WHILE (UNIVERSIDAD[I].NOMBRE <> `UCM') DO
I:=I+1;
AUX_FAC := UNIVERSIDAD[I].SIG;
WHILE (AUX_FAC <> NIL) DO
BEGIN
AUX_CUR := AUX_FAC^.PROX;
WHILE (AUX_CUR<>NIL) AND (AUX_CUR^.NOMBRE<>`PRIMERO')
DO
AUX_CUR := AUX_CUR^.PROX;
IF AUX_CUR^.NUMERO >1000 THEN
WRITELN(AUX_FAC^.NOMBRE);
AUX_FAC := AUX_FAC^.SIG;
TYPE
puntero=^nodo; nodo=RECORD info: ...; ant,sig: puntero; END; VAR comienzo, fin: puntero; CREACIÓN DE UNA LISTA DOBLE CON N NODOS: NEW (comienzo); READ (comienzo^.info); comienzo^.ant:=NIL; fin:=comienzo; FOR I:=1 TO N DO BEGIN NEW(fin^.sig); fin^. sig^.ant:=fin; fin:=fin^.sig READ (fin^.info); END; fin^.sig:=NIL; INSERTAR UN NODO DESPUES DEL NODO QUE APUNTA P: NEW (aux); aux^.info:=elem; aux^.sig:=p^.sig; aux^.ant:=p;
p^.sig:=aux; aux^. sig^.ant:=aux; EJER 18: Hacer un algoritmo que intercambie los nodos que ocupan las posiciones k y k+1, modificando unicamente los campos sig. PROCEDURE INTERCAMBIAR(VAR LISTA:PUNTERO; K:INTEGER); VAR AUX, ANT : PUNTERO; CONT : INTEGER; BEGIN IF K>=1 THEN BEGIN ANT := LISTA; AUX := LISTA^.SIG; IF (K=1) AND (AUX<>NIL) THEN BEGIN ANT^.SIG := AUX^.SIG; AUX^.SIG := ANT; LISTA := AUX; END ELSE BEGIN CONT := 2; {contador de nodos} WHILE (CONT<>K) AND (AUX<>NIL) DO BEGIN AUX := AUX^.SIG; ANT := ANT^.SIG; CON := CONT+1;
2.− IMPLEMENTACIÓN EN PASCAL:
2.1.− ESTATICA O SECUENCIAL.
TYPE
TIPOPILA = RECORD
DATOS : ARRAY [ 1.. Max ] OF ...... ; CAB : 0 .. Max ; END ; VAR PILA1,PILA2 : TIPOPILA ; 2.2.− DINAMICA O ENLAZADA. TYPE TIPOPILA = ^ NODO NODO = RECORD INFO : ...... ; SIG : TIPOPILA ; END ; VAR PILA1,PILA2 : TIPOPILA ; 3.− OPERACIONES CON PILAS. A continuación vamos a ver los algoritmos de las operaciones más comunes que se realizan con pilas : 3.1. LIMPIAR PILA. En ambos casos ( tanto en la estática como en la dinámica ) será un procedimiento en el que se pasa como parámetro una pila. a ) Estática PROCEDURE LIMPIA_PILA ( VAR PILA1: TIPOPILA ) ; BEGIN
PILA1. CAB := 0 ;
END ;
b) Dinámica PROCEDURE LIMPIA_PILA ( VAR PILA1: TIPOPILA ) ; BEGIN PILA1:= NIL ; END ; 3.2. FUNCION PILA VACIA. Vamos a hacer una función BOOLEAN que recibe una pila como parámetro y devuelve .T. si está vacia o .F. si no lo está. a) Estática FUNTION PILA_VACIA ( VAR PILA1: TIPOPILA ) : BOOLEAN ; BEGIN PILA_VACIA := PILA1. CAB = 0 ; END; b) Dinámica FUNTION PILA_VACIA ( VAR PILA1: TIPOPILA ) : BOOLEAN ; BEGIN PILA_VACIA := PILA1 = NIL ; END; 3.3. FUNCION PILA LLENA. Vamos a hacer una función BOOLEAN que recibe una pila como parámetro y devuelve .T. si está vacia o .F. si no lo está. a) Estática FUNTION PILA_LLENA ( VAR PILA1: TIPOPILA ) : BOOLEAN ; BEGIN PILA_LLENA := PILA1. CAB = MAX ;
ELEM := PILA1. DATOS [PILA1. CAB];
PILA1. CAB:= PILA1. CAB−1;
END;
END;
b) Dinámica. PROCEDURE SACAR ( VAR PILA1: TIPOPILA ; ELEM : ....) ; VAR AUX : TIPOPILA ; BEGIN IF NOT ( PILA_VACIA ( PILA1 )) THEN BEGIN ELEM := PILA1. INFO ; AUX := PILA 1 ; PILA1 := PILA1^. SIG ; DISPOSE ( AUX ) ; END; END; EJER 19: Hacer un algoritmo que visualize el contenido de una lista enlazada simple en orden inverso. El puntero a comienzo es ` lista'. Es decir, dada una lista enlazada simple visualizarla al reves. LIMPIA_PILA ( PILA1 ) ; AUX := LISTA ; WHILE ( AUX <>NIL ) DO BEGIN INSERTAR ( PILA1 , AUX ^. INFO ) ; AUX := AUX ^. SIG ; END ; WHILE NOT PILA_VACIA ( PILA1 ) DO BEGIN
SACAR ( PILA1 , ELEM ) ;
WRITELN ( ELEM ) ;
END ;
EJER 20: Se dispone de una pila de números enteros y de 2 variables enteras que se llaman VIEJA y NUEVA. Hacer un algoritmo que reemplace de la pila el elemento que contiene VIEJA por el valor de NUEVA, dejando el resto de la pila como estaba. limpiarpila(pilaaux); enc := falso; mientras (no pilavacia(pila)) y (no enc) sacar(pila,h) si h = vieja enc := verdad meter(pila,nueva) sino meter(pilaaux,h) fin fin mientras no pilavacia(pilaaux) sacar(pilaaux,h) meter(pila,h) fin EJER 21: Averiguar si una frase es políndroma o no lo es. nota : cuidado con los blancos. EJ: dabale arroz a la zorra el abad FUNCTION POLINDROMA(FRASE : STRING):BOOLEAN; VAR PILA : TIPOPILA; BEGIN LIMPIARPILA(PILA);
FRENTE FINAL
2.− IMPLEMENTACIÓN.
Declaración de tipos y variables. 2.1.− ESTÁTICA. Se representa con un vector y dos números. El nº frente me da la posición del primero en salir y el nº final el último en entrar. Vamos a hacer un vector circular. COLALLENA COLAVACIA frente siguiente a final frente siguiente a final IMPLEMENTACIÓN ERRONEA Para obtener una implementación correcta dejaremos una posición libre en el vector, tenemos dos opciones para dejar una posición vacia: 1ª− final va una posición por delante del último elemento que entró. 2ª− frente va una posición por detras del primer elemento en salir. Vamos a optar por la 2ª opción. COLALLENA COLAVACIA frente siguiente a final frente = final CONST max=? TYPE tipocola = RECORD datos : ARRAY [1..max[ OF ... ; frente,final : 1..max ; END; VAR cola : tipocola; 2.2.− DINÁMICA. Frente Final TYPE puntero = ^nodo; nodo = RECORD
dato : ... ; sig : puntero; frente final END; tipocola = RECORD frente,final : puntero; COLA END; VAR cola : tipocola;
3. OPERACIONES. 3.1.− INICIALIZAR COLAS. ESTÁTICA (Secuencial): PROCEDURE INICOLA (VAR cola : tipocola); BEGIN cola.frente := max; cola.final := max; END; DINÁMICA: PROCEDURE INICOLA (VAR cola : tipocola); BEGIN cola.frente := NIL; cola.final := NIL; END; 3.2.− FUNCIÓN COLAVACIA. SECUENCIAL: FUNCTION COLAVACIA (cola : tipocola): BOOLEAN; BEGIN colavacia := cola.frente :=cola.final;
BEGIN
IF NOT colavacia(cola) THEN BEGIN NEW(aux); aux^.dato:=elem; cola.final^.sig:=aux; cola.final:=aux; END ELSE BEGIN NEW(aux); aux^.dato:=elem; cola.frente:=aux; cola.final:=aux; END; END; 3.5.− SACAR UN ELEMENTO DE LA PILA. SECUENCIAL: (se extrae por el frente) PROCEDURE EXTRAER (VAR cola : tipocola;VAR elem: ... ); BEGIN IF NOT colavacia(cola) THEN BEGIN IF cola.frente=Max THEN cola.frente:= ELSE cola.frente:=cola.frente+1; elem:=cola.datos[cola.frente[ ; END;
END;
DINÁMICA:
PROCEDURE EXTRAER (VAR cola : tipocola;VAR elem: ... ); BEGIN IF NOT colavacia(cola) THEN BEGIN IF cola.frente=cola.final THEN BEGIN aux:=cola.frente; cola.frente:=NIL; cola.final:=NIL; elem:=cola.frente^.dato; DISPOSE(aux); END ELSE BEGIN elem:=cola.frente^.dato; aux:=cola.frente; cola.frente:=aux^.sig; DISPOSE(aux); END; END; END; EJER 22: Se tiene un array de 20 colas cuyo nº de elementos puede variar entre 0 y 1000 elementos. Cada cola tiene una prioridad distinta de 1 a 20, siendo la 1 la mas alta y la 20 la mas baja. 1−Hacer la declaración. 2− Insertar un elemento en la cola de prioridad n. 3− Extraer un elemento de la cola de mayor prioridad no vacia.
