Здравствуйте, angel.nero!
не берусь за полное выполнение вашего вопроса, ибо задано слишком много вопросов(и помоему не до конца)

Характеристика СД типа «линейный список»

1. Абстрактный уровень представления СД:
1.1 Конечная последовательность однотипных элементов (узлов). Количество элементов в последовательности называется длиной списка, причем длина в процессе работы программы может изменяться, поэтому ЛС – динамическая структура.
1.2 Набор допустимых операций:
1. Инициализация.
2. Включение элемента.
3. Исключение элемента.
4. Чтение текущего элемента.
5. Переход в начало списка.
6. Переход в конец списка.
7. Переход к следующему элементу.
8. Переход к i-му элементу.
9. Определение длины списка.
10. Уничтожение списка.
2. Физический уровень представления СД:
2.1 Последовательная или связная схема хранения.
2.2 Размер памяти зависит, прежде всего, от реализации линейного списка.
2.4 CAR(ЛС)= CAR(BaseType)0 +CAR(BaseType)1+… +CAR(BaseType)max
2.5 Тип доступа к элементам в зависимости от реализации.


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


Желаю удачного понимания! Спрашивайте что непонятно

Приложение:
Unit List3;
Interface
Const ListOk = 0;
ListNotMem = 1;
ListUnder = 2;
ListEnd = 3;
Type BaseType = Pointer;
PtrEl = ^Element;
Element = Record
Data : BaseType;
Next : PtrEl;
end;
List = Record
Start, Ptr : PtrEl;
N : Word; { длина списка }
Size : Word { размер информационной}
End; { части элемента }
bytearr = array[1..100] of integer;
Var ListError : 0..3;

Procedure InitList(var L:List; Size:Word);
Procedure PutList(var L:List; var E);
Procedure GetList(var L:List; var E:integer);
Procedure ReadList(var L:List; var E);
Function FullList(var L:List):boolean;
Function EndList(var L:List):boolean;
Function Count(var L:List):Word;
Procedure BeginPtr(var L:List);
Procedure EndPtr(var L:List);
Procedure MovePtr(var L:List);
Procedure MoveTo(var L:List; N:word);
Procedure DoneList(var L:List);
Procedure CopyList(var L1,L2:List);

implementation

Procedure InitList;
begin
getmem(L.start,sizeof(element));
if L.start=nil then
ListError:=ListNotMem
else
begin
L.start^.next:=nil;
L.ptr:=L.start;
L.N:=0;
L.size:=size;
end;
end;

Procedure EndPtr;
begin
L.ptr:=L.start;
while (L.ptr^.next)<>nil do
L.ptr:=L.ptr^.next;
end;

Procedure PutList;
var u:PtrEL;
i:word;
begin
u := L.ptr^.next;
getmem(L.ptr^.next, sizeof(element));
L.ptr := L.ptr^.next;
getmem(L.ptr^.data, L.size);
L.ptr^.next := u;
for i:=1 to L.size do
bytearr (L.ptr^.data^)[i]:=bytearr(E)[i];
inc(L.N)
end;

Procedure GetList;
var i:byte;
g:pointer;
begin
if L.N=1 then
ListError:=ListUnder
else
begin
L.ptr:=L.start;
i:=1;
while (L.ptr^.next<>nil)and(i<>E) do
begin
L.ptr:=L.ptr^.next;
inc(i)
end;
if i>E then
ListError:=ListEnd
else
begin
g:=L.ptr;
L.ptr:=L.ptr^.next;
freemem(g,sizeof(element))
end;
end;
end;

Procedure ReadList;
var i:word;
begin
for i:=1 to L.size do
bytearr(E)[i] := bytearr(L.ptr^.data^)[i];

end;


Function FullList(var L:List):boolean;
begin
FullList:=L.start=nil
end;

Function EndList;
begin
EndList:=L.ptr^.next=nil
end;

Function Count;
begin
Count:=L.N-1
end;

Procedure BeginPtr;
begin
L.ptr:=L.start
end;

Procedure MovePtr;
begin
if L.ptr^.next=nil then
ListError:=ListEnd
else
L.ptr:=L.ptr^.next
end;

Procedure MoveTo;
var i:byte;
begin
L.ptr:=L.start;
i:=1;
while (L.ptr^.next<>nil)and(i<>N) do
begin
L.ptr:=L.ptr^.next;
inc(i)
end;
end;

Procedure DoneList;
var g:pointer;
begin
L.ptr:=L.start;
while L.N<>0 do
begin
g:=L.ptr^.next;
freemem(L.ptr, sizeof(element));
L.ptr:=g
end;
freemem(L.start,sizeof(element));
end;

Procedure CopyList;
begin
L1.ptr:=L1.start;
while (L1.ptr^.next<>nil) do
begin
PutList(L2, L1.ptr^.data^);
L1.ptr:=L1.ptr^.next
end;
end;

end.

Здравствуйте, angel.nero!
Я только что приехал домой, времени на обдумывание ответа мало, но в общих чертах напишу алгоритмы добавления и удаления ячеек в список, если захотите более точный ответ то пишите в личку!

Описание списка:

Type powl:^owl;
info: integer;
owl=record
inf: integer;
next: powl;
end;

Создание первой ячейки:

procedure NewHead (var Head: powl; x:info);
var p:powl;

begin
new(p);
p^.info:=x;
p^.next:=head;
head:=p;
end;

Добавление ячейки в конец списка:

procedure NewCell (var Head: powl; x:info);
var c, p:powl;

begin

if head=nil then begin
new(head);
head^.inf:=x;
head^.next:=nil;
end

else begin
c:=head;
while c^.next<>nil do
c:=c^.next;
new(p);
c^.next:=p;
p^.inf:=x;
p^.next:=nil;
end;

end;

А теперь полное уничтожение списка:

procedure disposeowl(var head:powl);
var p:powl;

begin

while head<>nil do begin
p:=head;
head:=p^.next;
dispose(p);
end;

end;

В общем всё! В заключение скажу что любая процедура без описания типа не будет работать, поэтому сначала прописываете тип, а потом процедуры и кстати функция dispose(n) это удаление ячейки n, а n:=nil; это её обнуление(nil это ноль). Если что-нибудь не понятно пишите, буду рад помочь!