pila_c.pas

   1 unit PILA_C;\r
   2 {\r
   3 \r
   4         IMPLEMENTACION : pilas\r
   5 \r
   6         ALMACENAMIENTO : CURSORES\r
   7 }\r
   8 \r
   9 \r
  10 \r
  11 { ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
  12 \r
  13 interface\r
  14 \r
  15 { usa las funciones generales de TDAs }\r
  16 uses\r
  17    GRAL;\r
  18 \r
  19 { maximo tamano del cursor }\r
  20 const\r
  21    PILAC_MAX_CURSOR = 100;\r
  22 \r
  23 { tipos propios de la lista para definir el cursor }\r
  24 TYPE\r
  25         PILAC_puntero = integer;\r
  26 \r
  27 const\r
  28    PILAC_nulo : PILAC_puntero = 0;\r
  29 \r
  30 type\r
  31         PILAC_nodo = RECORD\r
  32                 Elem : T_REGISTRO;\r
  33                 Sig : PILAC_puntero;\r
  34         END;\r
  35 \r
  36    { ahora le toca definir el cursor }\r
  37    PILAC_Almac = record\r
  38       almacenamiento : array [ 1 .. PILAC_MAX_CURSOR ] of PILAC_Nodo;\r
  39       siguientes     : array [ 1 .. PILAC_MAX_CURSOR ] of PILAC_Puntero;\r
  40       primero_dispo  : PILAC_puntero;\r
  41    end;\r
  42 \r
  43    T_PILAC = RECORD\r
  44                 almac : PILAC_Almac;\r
  45                 primero: PILAC_puntero;\r
  46         END;\r
  47 \r
  48 { ========= }\r
  49 \r
  50 { INTERFASE }\r
  51 \r
  52 PROCEDURE PILAC_Inicializar( VAR l: T_PILAC );\r
  53 FUNCTION  PILAC_vacio( l: T_PILAC): BOOLEAN;\r
  54 FUNCTION  PILAC_lleno( l: T_PILAC): BOOLEAN;\r
  55 PROCEDURE PILAC_poner( VAR l: T_PILAC; VAR e: T_REGISTRO );\r
  56 PROCEDURE PILAC_sacar( VAR l: T_PILAC; VAR e: T_REGISTRO);\r
  57 PROCEDURE PILAC_vaciar( VAR l: T_PILAC );\r
  58 PROCEDURE PILAC_copiar( a: T_PILAC; VAR b: T_PILAC );\r
  59 \r
  60 \r
  61 implementation\r
  62 \r
  63 { CURSORES DE ESTA IMPLEMENTACION }\r
  64 { ========================================================================== }\r
  65 {  inicializar el almacenamiento }\r
  66 { PRE : 'almac' no esta inicializado  }\r
  67 { POST: 'almac' esta inicializado y vacio }\r
  68 \r
  69 procedure PILAC_Almac_Inicializar( VAR almac : PILAC_Almac );\r
  70  var\r
  71    i : PILAC_Puntero;\r
  72 \r
  73  begin\r
  74    almac.primero_dispo := 1;\r
  75    for i := 1 to PILAC_MAX_CURSOR - 1 do\r
  76    begin\r
  77       almac.siguientes[i] := i + 1;\r
  78    end;\r
  79    almac.siguientes[PILAC_MAX_CURSOR] := PILAC_Nulo;\r
  80  end;\r
  81 \r
  82 { ========================================================================== }\r
  83 {  saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
  84 { PRE : 'almac' esta inicializado  }\r
  85 { POST: si hay lugar en 'almac' para un nuevo elemento,\r
  86             entonces retorna TRUE y sino FALSE }\r
  87 function PILAC_Almac_HayLugar( almac : PILAC_Almac ): boolean;\r
  88  begin\r
  89    PILAC_Almac_HayLugar := not ( almac.primero_dispo = PILAC_Nulo );\r
  90  end;\r
  91 \r
  92 { ========================================================================== }\r
  93 {  el pedido de un nuevo elemento al almacenamiento }\r
  94 { PRE : 'almac' esta inicializado  }\r
  95 { POST: si hay lugar en 'almac' para un nuevo elemento,\r
  96             entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
  97             sino 'puntero' tiene el valor TTDA_Nulo }\r
  98 procedure PILAC_Almac_Reservar( VAR almac : PILAC_Almac; VAR puntero : PILAC_Puntero );\r
  99  begin\r
 100    if not PILAC_Almac_HayLugar( almac )\r
 101    then\r
 102       puntero := PILAC_Nulo\r
 103    else begin\r
 104       puntero := almac.primero_dispo;\r
 105       almac.primero_dispo := almac.siguientes[ puntero ];\r
 106    end;\r
 107  end;\r
 108 \r
 109 { ========================================================================== }\r
 110 {  liberar un elemento del almacenamiento }\r
 111 { PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento  }\r
 112 { POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
 113 procedure PILAC_Almac_Liberar( VAR almac : PILAC_Almac; VAR puntero : PILAC_Puntero );\r
 114  begin\r
 115    almac.siguientes[ puntero ] := almac.primero_dispo;\r
 116    almac.primero_dispo := puntero;\r
 117    puntero := PILAC_Nulo;\r
 118  end;\r
 119 \r
 120 { ========================================================================== }\r
 121 {  acceder al elemento del almacenamiento apuntado por un puntero }\r
 122 { PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento  }\r
 123 { POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
 124 procedure PILAC_Almac_Acceder( almac : PilaC_Almac; puntero : PILAC_Puntero; VAR elemento : PILAC_Nodo );\r
 125  begin\r
 126    elemento := almac.almacenamiento[ puntero ];\r
 127  end;\r
 128 \r
 129 { ========================================================================== }\r
 130 {  modificar el elemento del almacenamiento apuntado por un puntero }\r
 131 { PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
 132 { POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
 133 procedure PILAC_Almac_Modificar( VAR almac : PILAC_Almac; puntero : PILAC_Puntero; elemento : PILAC_Nodo );\r
 134  begin\r
 135    almac.almacenamiento[ puntero ] := elemento;\r
 136  end;\r
 137 \r
 138 { Estas son los dos procedimientos principales de la aplicación }\r
 139 PROCEDURE PILAC_Inicializar ( VAR l: T_PILAC );\r
 140  BEGIN\r
 141    PILAC_Almac_Inicializar( l.almac );\r
 142    l.primero := PILAC_Nulo;\r
 143  END;\r
 144 \r
 145 FUNCTION PILAC_vacio( l: T_PILAC): BOOLEAN;\r
 146  BEGIN\r
 147         PILAC_vacio := ( l.Primero = PILAC_Nulo);\r
 148  END;\r
 149 \r
 150 FUNCTION PILAC_lleno( l: T_PILAC): BOOLEAN;\r
 151  BEGIN\r
 152         PILAC_lleno := not PILAC_Almac_HayLugar( l.almac );\r
 153  END;\r
 154 \r
 155 PROCEDURE PILAC_poner ( VAR l: T_PILAC; var e: T_REGISTRO);\r
 156  VAR\r
 157    n : PILAC_Nodo;\r
 158    np: PILAC_Puntero;\r
 159 \r
 160  BEGIN\r
 161         n.Elem := e;\r
 162    n.sig := l.primero;\r
 163         PILAC_Almac_Reservar( l.almac, np );\r
 164    PILAC_Almac_Modificar( l.almac, np, n );\r
 165    l.primero := np;\r
 166  END;\r
 167 \r
 168 { pre: no esta vacia }\r
 169 PROCEDURE PILAC_sacar ( VAR l: T_PILAC; VAR e: T_REGISTRO);\r
 170  VAR\r
 171    n : PILAC_Nodo;\r
 172    tmp : PILAC_Nodo;\r
 173    tmpp: PILAC_Puntero;\r
 174 \r
 175  BEGIN\r
 176    PILAC_Almac_Acceder( l.almac, l.primero, n );\r
 177    PILAC_Almac_Liberar( l.almac, l.primero );\r
 178    l.primero := n.Sig;\r
 179    { y se lo asigno al parametro }\r
 180    e := n.Elem;\r
 181  END;\r
 182 \r
 183 PROCEDURE PILAC_vaciar ( VAR l: T_PILAC );\r
 184  VAR\r
 185    np : PILAC_Puntero;\r
 186    n : PILAC_Nodo;\r
 187 \r
 188  BEGIN\r
 189    np := l.primero;\r
 190    while( np <> PILAC_Nulo ) do begin\r
 191       PILAC_Almac_Acceder( l.almac, np, n );\r
 192       PILAC_Almac_Liberar( l.almac, np );\r
 193       np := n.sig;\r
 194       end;\r
 195    l.primero := PILAC_Nulo;\r
 196  END;\r
 197 \r
 198 { pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
 199 { POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
 200 PROCEDURE PILAC_copiar ( a : T_PILAC; VAR b : T_PILAC );\r
 201  VAR\r
 202    np, mp, tmpp : PILAC_Puntero;\r
 203    n,m : PILAC_Nodo;\r
 204 \r
 205  BEGIN\r
 206    if a.primero = PILAC_Nulo then exit;\r
 207    np := a.primero;\r
 208    PILAC_Almac_Acceder( a.almac, np, n );\r
 209    PILAC_Almac_Reservar( b.almac, mp );\r
 210    b.primero := mp;\r
 211    m.elem := n.elem;\r
 212    while( n.sig <> PILAC_Nulo ) do begin\r
 213       PILAC_Almac_Reservar( b.almac, tmpp );\r
 214       m.sig := tmpp;\r
 215       PILAC_Almac_Modificar( b.almac, mp, m );\r
 216       np := n.sig;\r
 217       PILAC_Almac_Acceder( a.almac, np, n );\r
 218       mp := tmpp;\r
 219       m.elem := n.elem;\r
 220       end;\r
 221    m.sig := PILAC_Nulo;\r
 222    PILAC_Almac_Modificar( b.almac, mp, m );\r
 223  END;\r
 224 \r
 225 end.\r
 226 \r