Pascal/Turbo Pascal - Duda implementación TAD Pila

   
Vista:

Duda implementación TAD Pila

Publicado por Sergio (11 intervenciones) el 19/04/2014 00:56:23
Buenas a todos. Escribo porque tengo una duda a la hora de implementar el TAD Pila en Pascal. Exactamente, el problema lo tengo a la hora de copiar una pila. Debo realizar una copia exacta de una pila recibida, y éste es el código que consideraba correcto para ello:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
PROCEDURE Copiar (VAR destino: TPila; origen: TPila);
VAR
	e,e2:TInfo;
	aux:TPila;
BEGIN
	IF EsPilaVacia(origen) THEN
		CrearPilaVacia(destino)
	ELSE
	BEGIN
		CrearPilaVacia(aux);
		WHILE NOT EsListaVacia(origen) DO
		BEGIN
			Cima(origen,e);
			Apilar(aux,e);
			Desapilar(origen);
		END;
		CrearPilaVacia(destino);
		WHILE NOT EsListaVacia(aux)DO
		BEGIN
			Cima(aux,e2);
			Apilar(destino,e2);
			Desapilar(aux);
		END;
	END;
END;
Lo que intento con ello es ir sacando elemento a elemento de la pila recibida, insertarlos en una pila auxiliar (quedando así una copia de la pila, pero invertida) y volver a realizar el mismo proceso para que en la pila destino quede una copia exacta de la pila origen.
No puedo cambiar la cabecera del subprograma, pues debo implementar la unidad en base a una interfaz dada (también la dejo por aquí):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
PROCEDURE CrearPilaVacia(VAR p: TPila);{O(?)}
{Pre = TRUE}
{Post = devuelve la pila vacía}
PROCEDURE Apilar(VAR p: TPila; e: TInfo);{O(?)}
{Pre = recibe una pila que puede ser vacía o no}
{Post = devu1elve la pila con el elemento e en la cima}
{Observadoras selectoras}
PROCEDURE Cima(p: TPila; VAR e: TInfo);{O(?)}
{Pre = Recibe la pila no vacía}
{Post = devuelve el primer elemento de la pila}
PROCEDURE Desapilar(VAR p: TPila);{O(?)}
{Pre = recibe una pila no vacía}
{Post = devuelve una pila sin el primer elemento de la original}
{Observadoras no selectoras}
FUNCTION EsPilaVacia(p: TPila): BOOLEAN;{O(?)}
{Pre = recibe una pila que puede ser vacía o no}
{Post = devuelve TRUE si la pila es vacía, FALSE en caso contrario}
PROCEDURE Copiar (VAR destino: TPila; origen: TPila);
{Pre = la variable origen es una pila creada, vacía o con elementos}
{Post = la variable destino es una copia exacta de la pila origen}
FUNCTION Iguales(p1, p2: TPila): Boolean;
{Pre = TRUE}
{Post = devuelve TRUE si las dos pilas son iguales}
PROCEDURE Destruir (VAR pila: TPila);
{Pre = TRUE}
{Post = libera la memoria utilizada y devuelve la pila vacía}

Muchas gracias de antemano
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Duda implementación TAD Pila

Publicado por ramon (2072 intervenciones) el 19/04/2014 23:01:48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
{Mira esto}
 
program pilas;
 uses
   crt;
 
  {PROCEDURE CrearPilaVacia(VAR p: TPila)
   PROCEDURE Apilar(VAR p: TPila; e: TInfo)
   PROCEDURE Cima(p: TPila; VAR e: TInfo);
   PROCEDURE Desapilar(VAR p: TPila);
   FUNCTION EsPilaVacia(p: TPila): BOOLEAN;
   PROCEDURE Copiar (VAR destino: TPila; origen: TPila);
   FUNCTION Iguales(p1, p2: TPila): Boolean;
   PROCEDURE Destruir (VAR pila: TPila);}
 
 type
   tpila = ^lapila;
   lapila = record
          dato : integer;
          sig : tpila;
         end;
 
   var
    copytem, mipila : tpila;
    u : integer;
 
 
  PROCEDURE CrearPilaVacia(VAR p: TPila);
  begin
     p := nil;
  end;
 
  PROCEDURE Apilar(VAR p : TPila; e : integer);
  var
    aux : tpila;
    begin
     new(aux);
     aux^.dato := e;
     aux^.sig := p;
     p := aux;
   end;
 
  FUNCTION EsPilaVacia(p: TPila): BOOLEAN;
  begin
     espilavacia := (p = nil);
  end;
 
  PROCEDURE Cima(p : TPila; VAR e : integer);
  begin
     if not(espilavacia(p)) then
     e := p^.dato;
   end;
 
  PROCEDURE Desapilar(VAR p : TPila);
  var
     aux : tpila;
   begin
     aux := p;
     p := p^.sig;
     dispose(aux);
  end;
 
  PROCEDURE Destruir(VAR pila : TPila);
  var
    aux : tpila;
    begin
     if not (espilavacia(pila)) then
      begin
        aux := pila;
        pila := pila^.sig;
        dispose(aux);
    end;
  end;
 
  PROCEDURE Copiar(VAR destino : TPila; origen : TPila);
  var
    temp : tpila;
  begin
      while origen <> nil do
      begin
       New(temp);
       temp^.dato := origen^.dato;
       temp^.sig := destino;
       destino := temp;
       origen := origen^.sig;
     end;
  end;
 
  begin
     clrscr;
     CrearPilaVacia(mipila);
     for u := 20 downto 1 do {for u := 1 to 20 do [para carga inversa}
     Apilar(mipila,u);
     Copiar(copytem,mipila);
     writeln('  Original ');
     writeln;
     while mipila <> nil do
     begin
        write('  ',mipila^.dato);
        mipila := mipila^.sig;
     end;
     writeln;
     writeln;
     writeln('  Copia ');
     writeln;
     while copytem <> nil do
     begin
        write('  ',copytem^.dato);
        copytem := copytem^.sig;
     end;
     readkey;
     Destruir(mipila);
     Destruir(copytem);
  end.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar