Динамические массивы и матрицы Опции

[Altair]

Модуль для работы с динамическими массивами.
Модуль позволяет работать с массивами с динамической длинной

Constructor INIT;
Инициализирует массив. Требуется запустить лишь один раз - в начале работы с массивом, но после определения начальной длины

Procedure SetSizeArray(_Size:word);
Устанавливает длинну массива равную _Size. При первом запуске, после нее требуется запустить конструктор.

Function GetSizeArray:Word;
Возвращает текущую длинну массива. Лучше использовать ее и не открывать доступ к переменной sizeofarray, т.к. последствия могут быть непредсказуемые.

Procedure EnteringArray(visible:Byte;VideoMode:Byte);
Процедура ввода массива.
Не очень надежна, т.к. нет поддержки backspace, но зато возможен ввод в графическом режиме и возможно управлять отображением вводимых чисел. (Для вывода, скажем звездочек вместо вводимых символов, ставим параметр visible=<код звездочки>
Videomode может иметь RText или RGraph - соответственно ввод в текстовом и ввод в графическом режиме.
Внимание: если тип режима указан неверно, произойдет ошибка периода исполнения.

Procedure PrintCRTarray(Videomode:byte);
Вывод на экран массива. Возможны 2 режима как и у метода для ввода массива.

Procedure QSort(left,right:integer);
Быстрая сортировка массива.

Procedure HSort;
Пирамидальная сортировка массива. Полезна если вы уверены что массив почти или полностью отсортирован.

Function GetMaxElem:Telem;
Возвращает максимальный элемент массива.

Function GetMinElem:Telem;
Возвращает мимнимальный элемент массива.

Function GetNumMaxElem:Word;
Возвращает номер максимального элемента в массиве. (Первого, если таких элементов несколько)

Function GetNumMinElem:Word;
Возвращает номер минимального элемента.

Function ElemInArray(T:Telem):Word;
Проверяет вхождение элемента в массив. 0 - если не найдено, иначе индекс элемента.

Procedure InvertArray;
Инвертирует массив.

Вот программа демонстрирующая возможности модуля.

Исходный код

Program TEST_UNIT_ARRAYS;
Uses CRT,Arrays;
var
a:TArrayWork;
i,c:integer;
dlinna:word;
poisk:Telem;
begin
CLRSCR;
Writeln('Введите длинну:');
readln(dlinna);
a.SetSizeArray(dlinna);
a.Init; {теперь можно работать}
writeln;
a.EnteringArray(RealkeyV,RText);
writeln('Введенный массив:');
A.PrintCRTArray(RText);
writeln;
a.hsort;
writeln('Отсортированный массив:');
a.printcrtarray(RText);
writeln; writeln('Инвертированный:');
a.InvertArray;
a.printcrtarray(rtext);
writeln;
writeln('максимальный элемент: ',a.GetMaxElem);
Writeln('минимальный элемент: ',a.GetMinElem);
writeln('Номер Макс. элемента: ',a.getnummaxelem);
writeln('номер минимального элемента :',a.getnumminelem);
write('введите искомый элемент: '); readln(Poisk);
if a.eleminarray(poisk)=0 then
writeln('не найден!') else
Writeln('номер искомого элемента: ',a.eleminarray(poisk));

write('Введите новую длинну: ');readln(dlinna);
If dlinna<=a.GetSizeArray then a.SetSizeArray(dlinna) else
begin
a.setsizearray(dlinna);
{a.init;}
end;
writeln('Элементы массива: ');
a.printcrtarray(rtext);
readln(a.arr^[dlinna-1]);
a.printcrtarray(rtext);
end.

В присоединенном файле сам модуль. (исходник).

ЗЫ: при реализации динамического массива, использовался алгоритм, предложенный volvo

Сообщение отредактировано: klem4 - 21.12.2005 1:22

[volvo]

Работа с динамическими массивами
Для того, чтобы работать с динамическими массивами, необходимо перед началом работы выделить память под такой массив, а после использования массива - освободить выделенную память:

{
  Обязательно отключить проверку индексов,
  иначе возникнет ошибка времени исполнения
}
{$R-}
Type
  TType = Integer; { Или любой другой тип }

  { Указатель на динамический массив }
  PDynArray = ^TDynArray;
  TDynArray = array[1 .. 1] of TType;

Var
  { Через эту переменную будет осуществляться вся работа с массивом }
  arr: PDynArray;

  n, i: integer;

Begin
  Write('n = '); ReadLn(n); { Вводится размер массива }

  {
    В "куче" запрашивается блок памяти с размером,
    достаточным для хранения N элементов типа TType
  }
  GetMem(arr, n * SizeOf(TType));

  (*** Начало работы с массивом ***)

  {
    Обращение к элементу динамического массива - почти такое же,
    как и к элементу обычного (статического) массива,
    за исключением операции "^" - разыменования ...

    Пример:
  }
  For i := 1 To n Do arr^[i] := 2 * i;

  For i := 1 To n Do
    Write(arr^[i]:4);

  (*** Закончили работу с массивом - уничтожаем его ***)

  { Возвращаем память назад в "кучу" }
  FreeMem(arr, n * SizeOf(TType));
End.

Дополнительная информация о реализации динамических массивов (ООП - версия) доступна здесь:
Модуль для работы с дин. массивом

[volvo]

Работа с динамическими матрицами
Для того, чтобы работать с динамическими матрицами, проще всего представить матрицу, как массив векторов (массив, содержащий указатели на строки матрицы). Перед началом работы с такой матрицей нужно сначала выделить память под массив указателей на строки, и только потом выделять память для хранения самих данных. После использования матрицы выделенная память освобождается в обратной последовательности:

{
  Обязательно отключить проверку индексов,
  иначе возникнет ошибка времени исполнения
}
{$R-}
Type
  TType = Word; { Или любой другой тип }
Type
  PVector = ^TVector;
  { Это - одна "строка" динамической матрицы }
  TVector = Array[1 .. 1] of TType;

  PDynMatrix = ^TDynMatrix;
  { Сама матрица - представляется как массив указателей на "строки" }
  TDynMatrix = Array[1 .. 1] of PVector;

Var
  { Через эту переменную будет осуществляться вся работа с матрицей }
  mxDynamic: PDynMatrix;
  n, i, j: Word;
Begin
  Write('n = '); ReadLn(n);

  { Выделяем память под указатели на "строки" }
  GetMem(mxDynamic, n * SizeOf(PVector));
  { И для каждой "строки" - выделяем память для хранения данных } 
  For i := 1 To n Do
    GetMem(mxDynamic^[i], n * SizeOf(TType));

  (*** Работаем с матрицей ***)
  {
    Динамическая матрица представлена немного иначе,
    чем динамический массив, поэтому для того, чтобы обратиться
    к ее элементу, необходимы 2 операции разыменования указателей.
    Пример:
  }
  For i := 1 To n Do { Строки }
    For j := 1 To n Do { Столбцы (элементы строки) }
      mxDynamic^[I]^[J]:=I*J;

  For i := 1 To n Do Begin
    WriteLn;
    For j := 1 To n Do
       Write(mxDynamic^[I]^[J]:4);
  End;

  (*** Закончили работу с матрицей - уничтожаем ее ***)

  { Освобождаем память в обратном порядке: }
  { Сначала - удаляем все "строки" }
  For i := 1 To n Do
    FreeMem(mxDynamic^[i], n * SizeOf(TType));
  { А теперь и указатели на них ... }
  FreeMem(mxDynamic, n * SizeOf(PVector));
End.

Дополнительная информация о реализации динамических матриц (ООП - версия) доступна здесь:
Модуль для работы с дин. матрицей

[Артемий]

Динамическая матрица с использованием функций ptr(), seg(), ofs() для получения указателя на нужное число.

const
  n = 6;

type
  PInt = ^integer;

var
  i, j: integer;
  PtrStr: array [1 .. n] of pointer;
  pr: PInt;
begin
  for i := 1 to n do
    getmem(PtrStr[i], n*sizeof(Integer));

  for i := 1 to n do
    for j := 1 to n do begin
      pr := Pint(ptr(seg(PtrStr[i]^), ofs(PtrStr[i]^)+(j-1)*sizeof(Integer)));
      pr^ := i + j;
    end;

  for i := 1 to n do begin
    writeln;
    for j := 1 to n do begin
      pr := PInt(ptr(seg(PtrStr[i]^), ofs(PtrStr[i]^)+(j-1)*sizeof(Integer)));
      write(pr^:4);
    end;
  end;

  for i := 1 to n do
    freemem(PtrStr[i],n*sizeof(Integer));
end.

Сообщение отредактировано: volvo - 10.01.2009 18:08