Составить программу . которая переносит в конец непустого списка L эго первый элемент

Для начала надо составить программу, которая инициализирует и заполняет список... Если она готова - покажи, как ты это сделала, мы покажем, как реализовать то, что написано в задании...

не знаю (((

kess, читай внимательнее:

По этому поводу загляни в FAQ: Все о динамических структурах данных.

program spisok_18;
uses crt;
type mas=array[1..100] of real;
    
var
    L:^mas;
   
    i,k:integer;
Begin
     clrscr;
     write('Vvedite kol-vo elementov '); read(n);

задание списка.... можно так??

как можно первый эл-т перенети в конец?

У тебя пока нет ни списка, ни последнего элемента, ни первого.
А вообще - просто перекинуть указатели.
Last^.Next будет равен бывшему First^.next, First^.next станет nil. Предпоследний^.next будет указывать на бывший первый.

ес чесно слабо се представляю как это вообще делать

Нет, так нельзя.
Это типа вместо того, чтобы строить дом, просто написать на земле: ДОМ.
Вот и живи в таком..

Прочитай ссылку, что я назвал..

В посте №4 тебе привели ссылку, по которой показано, и как описывается список, и как в него добавляется элемент, и многое другое... Понимаешь, когда этот вопрос задают в сотый раз - и при этом еще и не читают того, что было предложено - мотивации отвечать просто нет ...

да я читала... тока всё равно не пойму как этот список составить.....

Не значит ли это, что надо прочитать еще раз?

я просто не понимаю...... (((((((

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

Пока скажи:
1. ты в курсе, что такое есть указатель (pointer)?
2. А что такое record?
3. Или/и скажи, что именно вызывает затруднения в материале по той ссылке.

ну в курсе, но учитывая, что я вторые сутки вообще не сплю... трудно что-либо сообразить

Смотри.
Допустим, ты составляешь список цитат (то есть строк).
Вот основа твоего списка:

type
  pList=^tList;
  tList=record
    Next:pList;
    Q:string
  end;

В ней ты определяешь элемент списка. Он состоит из двух полей: самой цитаты (строки) и указателя на следующий элемент. Перед определением типа элемента стоит определение ссылки на этот тип - это необходимо сделать именно в таком порядке.

Затем тебе нужна переменная для этого списка:

var
  Quatations:pList;

В программе нужно прежде всего эту переменную инициализировать нулевым пойнтером (Nil). Это можно сделать прямо в теле программы, но лучше соорудить для этого специальную процедуру:

procedure InitList(var L:pList);
begin
  L:=Nil
end;

Таким образом, самая простая прога, которая заводит список, но не заполняет его, выглядит так:

type
  pList=^tList;
  tList=record
    Next:pList;
    Q:string
  end;

procedure InitList(var L:pList);
begin
  L:=Nil
end;

var
  Quatations:pList;

begin
  InitList(Quatations)
end.

to be continued..

Program spisok;
Uses CRT;
Type mas=array[1..10] of string;
Var
 tmp:string;
  L:^mas;
 n,i:integer;
Begin
CLRSCR;
 {Vvod spiska}
        n:=5;

 for i:=1 to n do
 begin
  WriteLn('Vvedite element #',i,': ');
  ReadLN(L^[i]);
                WriteLn;
 end;

 {peremeshenie}
 tmp:=L^[1];
 for i:=0 to n-1 do
        begin
   L^[i]:=L^[i+1];
        end;
 L^[n]:=tmp;
 
 {vivod}
 WriteLn;
 for i:=0 to n-1 do
   WriteLn('L[',i+1,']=',L^[i+1]);
 Repeat Until Keypressed;
End.

нет, kess.. Это и близко не лежало со списками. Это просто массив (если даже закрыть глаза на ошибки в проге). Массив - это не динамическая структура данных (см. свой заголовок).
Пойми, от тебя требуется нечто совершенно другое.
Список - это такая штука...
Допустим - ты белка .
Ты нашла орех - пока только один - и хочешь его спрятать. В специальном укромном месте ты пишешь:
"орех в кладовке на пятой полке". Потом действительно кладешь орех в кладовку на пятую полку - и все. Идешь гулять.

Потом ты находишь еще орех.. Ты идишь в то самое спец.укромное место и читаешь: "орех в кладовке на пятой полке". Ты идешь в кладовку, заглядываешь на пятую полку и рядом с орехом кладешь записку: "еще один орех в столе в нижнем ящике". Потом идешь к столу и кладешь второй орех в нижний ящик..

Потом ты находишь еще один орех. Ты идешь в спец.укромное место, там видишь записку про кладовку, идешь в кладовку на пятую полку, там видишь записку про нижний ящик стола. Идешь к столу, открываешь нижний ящик и видишь там орех и никакой записки (указатель Nil). Ты снова пишешь записку: "еще один орех под стулом". Идешь под стул, кладешь туда орех и идешь гулять..

И так какждый раз: тебе нужно пройти всю цепочку с начала (спц.укромное место) чтобы найти последний орех. Признак того, что он действительно последний - это около него нет записки. Ясно?

Вот это и есть список

Аналогия с кладовками и столами не очень хороша. Лучше - настоящая белка в лесу выкапывает ямки, прячет в каждую из них орех и кладет записку о том, где искать следующую ямку. В последней ямке записки нету.

В этой аналогии "вырыть ямку" означает взять память под новый элемент списка (процедура New). Здесь можно усмотреть также, зачем нужна вся эта мутотень.. Вот:
Массив - это хорошо. Это как одна яма на много орехов, но без возможности ее расширения! Если массив заполнен - все, больше орехи прятать некуда..
Этот способ (список) позволяет использовать всю доступную тебе память машины (хоть весь лес заполни ямками). В этом и есть основное преимущество. Оно не очень заметно, если у тебя вся задача - это один такой список. Но если их несколько, и ты не знаешь заранее, сколько каждый из них может занять места, то это весьма разумное решение, оно использует память наиболее рациональным образом по мере заполнения. Правда, есть накладные расходы на указатели, но если размер данных в элементе списка достаточно велик, то они относительно малы.

Вот вариант программы, который осуществляет заполнение списка и распечатку его в конце.

type
  pList=^tList;
  tList=record
    Next:pList;     {записка-указатель на след ямку}
    Q:string        {тут будет сам орех}
  end;

procedure AddToList(s:string; var L:pList);
var
  M:pList;
begin
  if L=Nil then begin  {если ямок еще не было}
    New(L);            {выкапываем самую первую ямку}
    M:=L
  end                  {если ямки уже были}
  else begin
    M:=L;
    while M^.Next<>Nil do M:=M^.Next;  {находим последнюю из них}
    New(M^.Next);      {выкапываем следующую и кладем записку, где она}
    M:=M^.Next
  end;
  M^.Q:=s;             {кладем орех в ямку}
  M^.Next:=Nil  {убираем записки, которые могли случайно оказаться в ямке}
end;

procedure PrintList(L:pList);
begin
  while L<>Nil do with L^ do begin {начинаем с первой ямки и повторяем до той, в которой нет записки}
    WriteLn(Q);        {достаем орех}
    L:=Next            {переходим к следующей ямке}
  end
end;

procedure InitList(var L:pList);
begin
  L:=Nil               {кладем записку, что орехов нет}
end;

var
  Quatations:pList;
  s:string;

begin
  InitList(Quatations);
  WriteLn('Введите несколько цитат (для завершения введите пустую строку):');
  repeat
    ReadLn(s);                             {находим орех}
    if s<>'' then AddToList(s,Quatations)  {кладем его в следующую ямку}
  until s='';
  PrintList(Quatations)      {достаем все орехи}
end.

Осталось добавить сюда то, что тебе нужно сделать по заданию: перенести в конец списка его первый элемент..

Теперь у тебя есть несколько (много) орехов, зарытых в ямки с записками. И тут ты вспоминаешь: первый орех был грецкий, а все остальные - обычные лесные.. И ты решаешь: грецкий орех надо оставить на закуску, то есть съесть последним. Но как это сделать? ведь он лежит в самой первой ямке!

Первая мысль: переложить все орехи по новой. Но это столько трудов... и делать нужно аккуратно..
Вторая мысль: переложить только первый и последний орехи. Но грецкий орех такой здоровенный, он едва влезает тебе в пасть - тащить его тяжело..
И вдруг тебя озаряет: надо переложить только записки!

1. Берешь самую первую записку (из спец.укромного места) - она указывает на ямку с грецким орехом - и кладешь ее пока в карман.

2. Берешь записку из первой ямки (с грецким орехом) - она указывает на вторую ямку - и кладешь ее в спец.укромное место. Теперь список начинается со второй ямки, а в бывшей первой ямке (с грецким орехом) записки нет совсем.

3. Проходишь по всему списку, находишь последнюю ямку (в ней нет записки) и кладешь туда записку из кармана, которая указывает на ямку с грецким орехом. Она была первой - стала последней (на нее указывает бывшая последняя ямка, которая теперь стала предпоследней). Записки в ней нет (см. п.2), что согласуется с признаком последней ямки.

Все, перекладывание закончено. Мы перекладывали только указатели (записки), а не сами данные (орехи), что сэкономило нам силы и время. Это еще одно преимущество списков, не сразу заметное. Представь себе, что данные в элементе исчисляются мегабайтами, а также, что тебе надо отсортировать список (много перекладываний) - и поймешь..

Вот программа, которая реализует приведенный алгоритм:

type
  pList=^tList;
  tList=record
    Next:pList;     {записка-указатель на след ямку}
    Q:string        {тут будет сам орех}
  end;

procedure AddToList(s:string; var L:pList);
var
  M:pList;
begin
  if L=Nil then begin  {если ямок еще не было}
    New(L);            {выкапываем самую первую ямку}
    M:=L
  end                  {если ямки уже были}
  else begin
    M:=L;
    while M^.Next<>Nil do M:=M^.Next;  {находим последнюю из них}
    New(M^.Next);      {выкапываем следующую и кладем записку, где она}
    M:=M^.Next
  end;
  M^.Q:=s;             {кладем орех в ямку}
  M^.Next:=Nil  {убираем записки, которые могли случайно оказаться в ямке}
end;

procedure PrintList(L:pList);
begin
  while L<>Nil do with L^ do begin
    WriteLn(Q);        {достаем орех}
    L:=Next            {переходим к следующей ямке}
  end
end;

procedure InitList(var L:pList);
begin
  L:=Nil               {кладем записку, что орехов нет}
end;

var
  Quatations,M,t:pList;
  s:string;

begin
  InitList(Quatations);
  WriteLn('Введите несколько цитат (для завершения введите пустую строку):');
  repeat
    ReadLn(s);                             {находим орех}
    if s<>'' then AddToList(s,Quatations)  {кладем его в следующую ямку}
  until s='';

  if Quatations=Nil then WriteLn('Список пуст!')
  else if Quatations^.Next<>Nil then begin
    WriteLn('Введенный список:');
    PrintList(Quatations);
    t:=Quatations;                      {это твой карман}
    Quatations:=Quatations^.Next;      {в начало кладем записку из первой ямки}
    M:=Quatations;
    while M^.Next<>Nil do M:=M^.Next;   {проходим по всем ямкам до последней..}
    M^.Next:=t;            {.. и кладем в нее записку из кармана}
    t^.Next:=Nilж
    WriteLn; WriteLn('Переставленный список:');
    PrintList(Quatations)
  end
end.

Теперь тебе понятно, что такое списки?..

Lapp, вот ты когда объясняешь что-то, ты намеренно приводишь сначала некорректный (ну, скажем так, не совсем корректный) вариант, чтобы потом было что добавить, или как?

Кто же по ходу добавления в список ПОСТОЯННО ищет его "хвост"? Хранится указатель на него, но не постоянно же производить лишние операции... Попробуй оценить, сколько лишнего ты сделаешь, пока заполнишь список, скажем, 1000 значений... Ну, или хотя бы сотней.

Да, намеренно..
Я считаю, что человек должен вначале понять структуру. Принципиальную структуру.
Я думаю, что хранение хвоста - это оптимизация, а оптимизация делается тогда, когда есть четкое понимание основы. Можно хранить и еще что-то промежуточное.. не в этом главное.
Может, я ошибаюсь, но у меня такое представление об обучении. Так сказать, имхо .

Подключайся - дополняй, исправляй . Я же не против..
Я могу ошибаться не только в методологии (ну, ты знаешь.. )

по-моему, тогда стоит начать с нескольких часов нормального сна. А потом все внимательно прочитать и задать конкретные вопросы. (а не говорить: "Я совсем ничего не понимаю").