Программа на списки на статистической памяти, не знаю как написать инвертирование Опции

[Lint]

Помогите плс с решением задачи
Такая программа: "Создать еа статистической памяти список строк(словарь). Реализовать функцию, инвертирующую список."

Не знаю как написать функцию инвертирования, точнее написал, но она не работает(((

Вот что получилось:

Program dict;
Uses crt;

Const N=100;
      Nul=-1;
Type Zapis = String;
Type Element = record(элемент списка, который состоит из записи и ссылки на следующий)
       Data: Zapis;
       Next: integer;
     end;
Type List = record(сам список в виде массива этих элементов)
       Data: array [1..N] of Element;
       Head: integer;
       Free: integer;
     end;

Var  Dict1:List;
     Size:integer;
     i:integer;
     SElem:zapis;
     Num:integer;
     a:string;
     Last:integer;
     Pred:integer;
     c:zapis;

Procedure Initial(var Dict1:List);(инициализация списка)
  var i: integer;
  begin
    Dict1.Free:=1;
    Dict1.Head:=Nul;
    for i:=1 to N-1 do
      begin
        Dict1.Data[i].Next:=i+1;
        Dict1.Data[N].Next:=Nul;
      end;
  end;


Function CheckPoss(const Dict1:List; const Num:integer):boolean;(проверка наличия свободного элемента)
var Result:boolean;
   begin
    if ((Dict1.Free<>Nul) or (Num<=N)) then
    Result:=true
     else
      Result:=False;
     CheckPoss:=Result;
   end;

Function GetFreeElem(var Dict1:List):integer;(получнение номера свободного элемента)
  begin
    GetFreeElem:=Dict1.Free;
    Dict1.Free:=Dict1.Data[Dict1.Free].Next;
  end;

Procedure InsertItem(var Dict1:List; const Num:integer;
                     const FreeElem:integer; const SElem:zapis);(ввод значения нового элемента)
  begin
    Dict1.Data[FreeElem].Next:=Dict1.Data[Num].Next;
    Dict1.Data[Num].Next:=FreeElem;
    Dict1.Data[FreeElem].Data:=SElem;
  end;

Procedure AddListItem(var Dict1:List; const SElem:Zapis; Num:integer);(само добавление в список)
  var FreeItem:integer;
  begin
    if CheckPoss(Dict1,Num) then
      begin
        FreeItem:=GetFreeElem(Dict1);
        InsertItem(Dict1,Num,FreeItem,SElem);
      end;
  end;


Procedure AddHeadItem(var Dict1:List; const SElem:Zapis);(добавление в голову списка)
  var Num:integer;
  begin
    Num:=GetFreeElem(Dict1);
     if Num<>Nul then
      Begin
       Dict1.Data[Num].Next:=Dict1.Head;
       Dict1.Head:=Num;
       Dict1.Data[Num].Data:=SElem;
     End;
  end;


Procedure Print(const Dict1:List);(печать списка)
  var i:integer;
  begin
    i:=Dict1.Head;
    while i<>Nul do
      begin
        writeln(Dict1.Data[i].Data,' ');
        i:=Dict1.Data[i].Next;
      end;
  end;

Function LastElem(const Dict1:List; var Last:integer):integer;(поиск последнего элемента)
  Begin
    Last:=Dict1.Head;
      while Dict1.Data[Last].Next<>Nul do
       Begin
       Last:=Dict1.Data[Last].Next;
       End;
        LastElem:=Last;
  End;


Function FindPred(const Dict1:List; var Num:integer):integer;(поиск предыдущего элемента перед элементом с номером num)
 var pred:integer;
 Begin
  If Num<>Dict1.Head then
   Begin
   pred:=Dict1.Head;
    while (pred<>Nul) and (Dict1.Data[pred].Next<>Num) do
      pred:=Dict1.Data[pred].Next;
      FindPred:=pred;
      End
     else FindPred:=Nul;
  End;


Procedure Invert(var Dict1:List; Num:integer);(инвертирование списка, которое не получается)
  var pred:integer;
      i:integer;
      last:integer;
 Begin
  writeln('hotite invertirovat spisok?y/n');
  readln(a);
   if a='y' then
    Begin
      Num:=LastElem(Dict1,Last);
      pred:=FindPred(Dict1,Num);
      Dict1.Head:=Nul;
      while Num<>Nul do
       Begin;
        pred:=Dict1.Data[Num].Next;
        Num:=Pred;
        pred:=FindPred(Dict1,Num);
       End;
     print(Dict1);
    End;
 End;


Begin
  clrscr;
  Initial(Dict1);
  writeln('Ukazhite razmer slovarya (n<=',N,')');
  readln(Size);
      for i:=1 to Size do
      begin
        writeln('VVedite slovo:');
        readln(SElem);
        if i=1 then
         AddHeadItem(Dict1,SElem)
        else
         AddHeadItem(Dict1,SElem);
      end;
  Print(Dict1);
  writeln;
  Invert(Dict1,Num);
 readln;
End.

М

Используй теги

Сообщение отредактировано: klem4 - 17.03.2008 8:49

[volvo]

Что, это все нужно только для того, чтобы организовать список в статической памяти???

Мне почему-то казалось, что это делается гораздо проще:

program dict;

const
  n_max = 100;

type
  T = string;

  pitem = ^item;
  item = record
    data: T;
    next: pitem;
  end;

  tlist = record
    data: array[1 .. n_max] of item;
    first, last: pitem;

    free: integer;
  end;


procedure init(var L: tlist);
begin
  L.first := nil; L.last := nil; L.free := 1;
end;

procedure append(var L: tlist; value: T);
var p: pitem;
begin
  p := @(L.data[L.free]); inc(L.free);
  p^.data := value;
  p^.next := nil;

  if L.first = nil then L.first := p
  else L.last^.next := p;

  L.last := p
end;

procedure invert(var L: tlist);
var p, T: pitem;
begin
  if (L.first = nil) or (not assigned(L.first^.next)) then exit
  else begin
    p := nil; L.last := L.first;
    while assigned(L.first) do begin
      T := L.first^.next;
      L.first^.next := p;
      p := L.first;
      L.first := T
    end;
    L.first := p
  end
end;

procedure print(var L: tlist);
var p: pitem;
begin
  p := L.first;
  while assigned(p) do begin
    writeln(p^.data);
    p := p^.next
  end;
end;

var
  dict1: tlist;
  i, size: integer;
  s: string;

begin
  init(Dict1);
  writeln('Ukazhite razmer slovarya (n <= ', n_max, ')');
  readln(Size);

  for i :=1 to Size do begin
    writeln('VVedite slovo:');
    readln(s);
    append(dict1, s); { Добавляем элемент сразу в конец списка, и не надо никакого инверта... }
  end;

  print(Dict1);
  writeln;
  invert(Dict1); { но раз уж хочется - то вот тебе еще и инверт... }
  print(Dict1);
  readln;
end.

Проверок на переполнение списка не делал, для того, чтобы их добавить, придется слегка модифицировать процедуру Append...