Составить программу . которая переносит в конец непустого списка L эго первый элемент
Для начала надо составить программу, которая инициализирует и заполняет список... Если она готова - покажи, как ты это сделала, мы покажем, как реализовать то, что написано в задании...
kess, читай внимательнее:
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 тебе привели ссылку, по которой показано, и как описывается список, и как в него добавляется элемент, и многое другое... Понимаешь, когда этот вопрос задают в сотый раз - и при этом еще и не читают того, что было предложено - мотивации отвечать просто нет ...
Смотри.
Допустим, ты составляешь список цитат (то есть строк).
Вот основа твоего списка:
type
pList=^tList;
tList=record
Next:pList;
Q:string
end;
var
Quatations:pList;
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.
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.
Аналогия с кладовками и столами не очень хороша. Лучше - настоящая белка в лесу выкапывает ямки, прячет в каждую из них орех и кладет записку о том, где искать следующую ямку. В последней ямке записки нету.
В этой аналогии "вырыть ямку" означает взять память под новый элемент списка (процедура 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 значений... Ну, или хотя бы сотней.
Да, намеренно..
Я считаю, что человек должен вначале понять структуру. Принципиальную структуру.
Я думаю, что хранение хвоста - это оптимизация, а оптимизация делается тогда, когда есть четкое понимание основы. Можно хранить и еще что-то промежуточное.. не в этом главное.
Может, я ошибаюсь, но у меня такое представление об обучении. Так сказать, имхо .
Подключайся - дополняй, исправляй . Я же не против..
Я могу ошибаться не только в методологии (ну, ты знаешь.. )