Pascal/Turbo Pascal - Problema arboles.

Buenas tardes, tengo un problema que aunque no pide generar la estructura que contiene la información, yo la quiero generar, para poder hacer pruebas y ver si funciona como se debe.

El problema es el siguiente:
Un comercio de pastas frescas, dispone de una estructura con la información de las ventas que se
realizaron durante un mes. De cada venta se conoce: el código de pasta, cantidad, fecha y número de
cliente. Esta información no tiene ningún orden.

a)Se pide generar una estructura que almacene por cada código de pasta, la cantidad total vendida
durante dicho mes y los números de los clientes que la solicitaron (si el cliente solicitó más de una
vez un código de pasta, debe aparecer una sola vez para ese código de pasta). Esta estructura
debe estar ordenada por código de pasta y ser eficiente para la búsqueda por dicho criterio.

Una aclaración mia: el problema debe resolverse solo con arboles, la estructura que contiene la informacion no tiene que ser necesariamente un arbol. por eso yo elegi una lista para contener la información. y luego usar esa lista para generar el arbol.

No me funciona bien el programa, pero no se bien porque. De estar bien y solo necesitar unas correcciones me gustaria saberlas, si está casi todo mal estonces me gustaria que me mostracen como se tendría que hacer, para asi lo analizo bien y veo en que me equivoque. Desde ya muchas gracias.
Dev-Pascal

program ejercicio4;
type
info_individual = record
cod : integer;
cant : integer;
fecha: string;
numero_cliente : integer;
end;
lista_info = ^nodo_info;
nodo_info = record
elemen_info : info_individual;
dirSig_info : lista_info;
end;
lista = ^nodo_lista;
nodo_lista = record
cliente: integer;
dirSig: lista;
end;
info = record
cod_pasta : integer;
cant_vendida : integer;
nros_clientes : lista;
end;

T_arbol = ^nodo;
nodo = record
hijo_izq : T_arbol;
elemen : info;
hijo_der : T_arbol;
end;
procedure crear_arbol(var a: T_arbol);
begin
a := nil;
end;
procedure crear_lista(var L : lista_info);
begin
L := nil;
end;
procedure cargar_datos(var reg : info_individual);
begin
with (reg) do
begin
write('Ingrese el código de pasta: ');
readln(cod);
if (cod <> -1) then
begin
write('Ingrese la cantidad vendida: ');
readln(cant);
write('Ingrese la fecha: ');
readln(fecha);
write('Ingrese el número de cliente: ');
readln(numero_cliente);
end;
end;
end;
procedure agregar_cliente (var L : lista; num_cliente : integer);
var
ant, act : lista;
nue : lista;
begin
new(nue);
nue^.cliente:= num_cliente;
nue^.dirSig := nil;
act := L;
ant := act;
if (L = nil) then
L^.dirSig := nue
else
begin
while (act <> nil) do
begin
ant := act;
act := act^.dirSig;
end;
ant^.dirSig := nue;
end;
end;
procedure agregar_atras(var L: lista_info; reg: info_individual);
var
nue : lista_info;
begin
new(nue);
nue^.elemen_info := reg;
nue^.dirSig_info := nil;
L^.dirSig_info := nue;
end;


procedure cargar_lista(var L : lista_info);
var
reg : info_individual;
inicio_lista : lista_info;
begin
cargar_datos(reg);
if (reg.cod <> -1) then
begin
new(L);
L^.elemen_info := reg;
L^.dirSig_info := nil;
inicio_lista := L;
cargar_datos(reg);
while (reg.cod <> -1) do
begin
agregar_atras(L, reg);
L:= L^.dirSig_info;
cargar_datos(reg);
end;
L:= inicio_lista;
end;
end;
procedure imprimir_lista(L: lista_info);
begin
while (L <> nil) do
begin
writeln('Codigo de pasta: ', L^.elemen_info.cod);
writeln('Cantidad vendida: ', L^.elemen_info.cant);
writeln('Fecha: ', L^.elemen_info.fecha);
writeln('Codigo de cliente: ', L^.elemen_info.numero_cliente);
writeln();
L := L^.dirSig_info;
end;
end;
procedure imprimir_clientes(L : lista);
begin
write('Numeros de cliente: ');
while (L <> nil) do
begin
write(L^.cliente, ' ');
L := L^.dirSig;
end;
end;
procedure esta(list : lista; var ok: boolean; cod: integer);
begin
ok := false;
while ((list<> nil) and (ok <> true)) do
begin
if (list^.cliente = cod) then
ok := true;
list := list^.dirSig;
end;
end;

procedure actualizar_nodo_arbol(var list: lista_info; var a: T_arbol);
var
ok : boolean;
begin
if (list^.elemen_info.cod = a^.elemen.cod_pasta) then
begin
a^.elemen.cant_vendida := a^.elemen.cant_vendida + list^.elemen_info.cant;
esta(a^.elemen.nros_clientes, ok, list^.elemen_info.numero_cliente);
if (ok) then
agregar_cliente(a^.elemen.nros_clientes, list^.elemen_info.numero_cliente);
list := list^.dirSig_info;
end
end;
procedure crear_nodo_arbol(var a : T_arbol; list: lista_info);
begin
new(a);
a^.elemen.cod_pasta := list^.elemen_info.cod;
a^.elemen.cant_vendida := list^.elemen_info.cant;
a^.elemen.nros_clientes := nil;
agregar_cliente(a^.elemen.nros_clientes, list^.elemen_info.numero_cliente);
end;
procedure cargar_estructura(var a : T_arbol; var informacion : lista_info);
begin
if (a = nil) then
begin
new(a);
a^.elemen.cod_pasta := informacion^.elemen_info.cod;
a^.elemen.cant_vendida := informacion^.elemen_info.cant;
a^.elemen.nros_clientes := nil;
agregar_cliente(a^.elemen.nros_clientes, informacion^.elemen_info.numero_cliente);
end
else
begin
if (a^.elemen.cod_pasta = informacion^.elemen_info.cod) then
actualizar_nodo_arbol(informacion, a)
else
if (informacion^.elemen_info.cod >= a^.elemen.cod_pasta) then
cargar_estructura(a^.hijo_der, informacion)
else
cargar_estructura(a^.hijo_izq, informacion);
end;
end;
procedure imprimir_nodo_arbol(a: T_arbol);
begin
writeln('Codigo de pasta: ', a^.elemen.cod_pasta);
writeln('Cantidad vendida: ', a^.elemen.cant_vendida);
imprimir_clientes(a^.elemen.nros_clientes);
writeln();
end;
procedure recorrido_in_orden(a: T_arbol);
begin
if (a <> nil) then
begin
recorrido_in_orden(a^.hijo_izq);
imprimir_nodo_arbol(a);
recorrido_in_orden(a^.hijo_der);
end;
end;
{procedure recorrido_post_orden(a: T_arbol);
begin
if (a <> nil) then
begin
recorrido_post_orden(a^.hijo_izq);
recorrido_post_orden(a^.hijo_der);
write(a^.elemen, ' ');
end;
end;
procedure recorrido_pre_orden(a: T_arbol);
begin
if (a <> nil) then
begin
write(a^.elemen, ' ');
recorrido_pre_orden(a^.hijo_izq);
recorrido_pre_orden(a^.hijo_der);
end;
end;}
var
list : lista_info;
arbol : T_arbol;
inicio : lista_info;
begin
crear_lista(list);
crear_arbol(arbol);
cargar_lista(list);
imprimir_lista(list);
inicio := list;
crear_nodo_arbol(arbol, list);
cargar_estructura(arbol, list^.dirSig_info);
list:= inicio;
writeln();
recorrido_in_orden(arbol);
writeln();
readln();
readln();
end.