Реализация хеш-таблицы через список, удаление элемента по ключу

Type Hash = ^PHash;
PHash = record
Data: integer; 
Next:hash;
End;
//Объявление таблицы:
Const m = 11;
type h_table=array [0..m-1] of hash;
var 
i,a: integer;
table: h_table; 
//инициализация
procedure preparation_h_table(var table:h_table); 
var i:integer;
begin
        for i:=0 to m-1 do
             table[i]:=nil;
end;
function hash_func(key:integer) : integer;
begin
        hash_func:=key mod m;
end;
//процедуры добавления в список
procedure addItem_to_Begin(var L:Hash;item:integer);
var Q:Hash;
begin
    new(Q);
    Q^.Data:=item;
    Q^.Next:=L;
    L:=Q;
end;
procedure addItem_to_End(var L:Hash; var T:Hash; item:integer);
var Q:Hash;
begin
        if L=nil then
        begin
                addItem_to_Begin(L,item);
                T:=L;
        end
        else
        begin
            T:=L;
            while T^.next<> nil do T:=T^.next;
            new(Q);
            Q^.Data:=item;
            Q^.Next:=nil;
            T^.Next:=Q;
            T:=Q;
        end;
end;
//добавление в таблицу
procedure add_to_hash(var table:h_table; key:integer);
var i:integer;
var T:hash;
begin
    i:= hash_func (key);
    addItem_to_End(table[i],T,key);
end;
//удаление по ключу
procedure find_Item_by_Key(L:Hash; key:integer; var T:Hash; var TPrev:Hash);
begin
    T:=L;
    while T<> nil do 
    begin
        if T^.Data=key then break;
        TPrev:=T;
        T:=T^.next;
    end;
end;
procedure delete_by_key(var L:Hash; key:integer);
var Q,T,TPrev:Hash;
begin
      find_Item_by_Key(L,key,T,TPrev);
      if TPrev<>nil then writeln ('предыдущий элемент ',TPrev^.Data);
      if TPrev=nil then writeln ('первый элемент');
      writeln ('нужный элемент ',T^.Data);
    if TPrev=nil then 
    begin
     Q:=L; 
     writeln ('нужный первый элемент ',Q^.Data);
     L:=Q^.next;
     writeln ('нужный следующий элемент ',Q^.Data);
    end
    else
    begin
    Q:=TPrev^.next;
      TPrev^.next:=Q^.next;
    end;
    Dispose (Q);
end; 
procedure delete_table_key(table:h_table; key:integer);
var i:integer;
begin
        for i:=0 to m-1 do
        if i=hash_func(key) then delete_by_Key (table[i],key);
end;
//вывод таблицы
procedure write_List(L:Hash);
var Q:Hash;
begin
    Q:=L;
    writeln;
    while Q<>nil do
    begin
        write(Q^.Data,' ');
        Q:=Q^.next;
    end;
end;
procedure write_h_table(table:h_table);
var i:integer;
begin
        for i:=0 to m-1 do
        if   table[i]=nil then 
        begin
          Writeln;
          Write('*');
        end
        else
             write_List(table[i]);
end;
begin
   preparation_h_table(table);
   //16,22,8,14,24,18,5,10,12,2,13,12,12,14,17,11,7,19,23,4,6,15,19,2,7
   for i:=0 to 24 do
   begin
   Readln (a);
   add_to_hash(table, a);
   end;
     write_h_table(table);
     writeln;
     delete_table_key (table,23);
     writeln;
     write_h_table(table);
end.

type
  MyHashSetNode<T> = class
    data: T;
    next: MyHashSetNode<T>; // экземляры классов и так хранятся по ссылке (перекрашенному указателю), поэтому засорять код лишними "^" не надо
  end;
  
  MyHashSet<T> = sealed class
    private const root_c = 16; // должно быть степенью двойки, а не 11, иначе будет медленно
    private roots := new MyHashSetNode<T>[root_c];
    
    private static function ContainsIn(n: MyHashSetNode<T>; a: T): boolean;
    begin
      while n<>nil do
      begin
        if n.data=a then
        begin
          Result := True;
          exit;
        end;
        n := n.next;
      end;
    end;
    
    /// Возвращает True если элемент уже содержится
    public function Contains(a: T): boolean;
    begin
      // из за того что root_c степерь двойки - можно применять побитовое and вместо mod, а это быстрее
      var root_id := a.GetHashCode and (root_c-1);
      Result := ContainsIn(roots[root_id], a);
    end;
    
    /// Добавляет элемент, если его ещё нет
    /// Возвращает True если новый элемент был добавлен
    public function Add(a: T): boolean;
    begin
      var root_id := a.GetHashCode and (root_c-1);
      if ContainsIn(roots[root_id], a) then exit;
      
      var nn := new MyHashSetNode<T>;
      nn.data := a;
      nn.next := roots[root_id];
      roots[root_id] := nn;
      
      Result := True;
    end;
    
    /// Удаляет элемент, если он есть
    /// Возвращает True если элемент был удалён
    public function Remove(a: T): boolean;
    begin
      var root_id := a.GetHashCode and (root_c-1);
      
      var n := roots[root_id];
      if n=nil then exit;
      if n.data=a then
      begin
        roots[root_id] := n.next;
        Result := True;
        exit;
      end;
      
      var prev := n;
      n := n.next;
      while n<>nil do
      begin
        
        if n.data=a then
        begin
          prev.next := n.next;
          Result := True;
          exit;
        end;
        
        prev := n;
        n := n.next;
      end;
      
    end;
    
    // вообще для этого лучше реализовать IEnumerable, но для простоты так:
    function EnmrAll: sequence of T;
    begin
//      for var i := 0 to root_c-1 do //ToDo сейчас так не видит root_c, https://github.com/pascalabcnet/pascalabcnet/issues/2152
      for var i := 0 to MyHashSet&<T>.root_c-1 do
      begin
        var n := roots[i];
        
        while n<>nil do
        begin
          yield n.data;
          n := n.next;
        end;
        
      end;
    end;
    
  end;
  
begin
  var hs := new MyHashSet<integer>;
  
  Writeln('Добавление 3 элементов в общий связный список:');
  hs.Add(5).Println;
  hs.Add(5+16).Println;
  hs.Add(5+16*2).Println;
  hs.EnmrAll.Println;
  Writeln;
  
  Writeln('Удаление 2 из них:');
  hs.Remove(5+16).Println;
  hs.Remove(5+16*2).Println;
  hs.Remove(5+16*2).Println; // второй раз уже вернёт False, потому что теперь такого элемента нет
  hs.EnmrAll.Println;
  Writeln;
  
  hs.Contains(5).Println;
  hs.Contains(6).Println;
  
end.