Список с указателем на последний элемент

@Опа!! · Регистрация: 30.09.2009

Студворк — интернет-сервис помощи студентам

Приветствую.
Есть циклический односвязный список с зацикливанием через голову.

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

-Инициализация *сделано*
-Удаление с освобождением памяти *сделано*
-Добавление\удаления в голову\хвост *сделано*
-Выдача текущего списка на экран *сделано*
-Поменять местами первый и последний узлы; *не сделано*
-Удалить узел с указанным порядковым номером; *не сделано*

Итого осталась два задания + передалать в список с указателям на последний узел. Прошу помощи) Поиск юзал

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
итого - осталось два невыполненных, прошу помощи! поиск юзал)
 
#include <iostream>
#include <stdio.h>
 
using namespace std;
 
struct lItem
{
    unsigned int data;  //item data
    lItem* next;  //next item
};
 
struct lList
{
    lItem* head;
    lItem* tail;
};
 
lList mList; //main list
 
//*************************************************************
/*Delete list*/
 
void deleteList( lList& oList )
{
    while( oList.head != oList.tail )  //delete all elements of the list except head
    {
        lItem* tmp;
        tmp = oList.head->next;
        delete oList.head;
        oList.head = tmp;
    }
 
    delete oList.head;  //delete head
    oList.tail = NULL;
}
 
//*************************************************************
/*Is list empty*/
 
bool isEmpty( lList& oList )
{
    return (oList.head == NULL);  //returns true if the list is empty else false
}
 
//*************************************************************
/*Initialize list*/
 
void initList( lList& oList )
{
    if( !isEmpty( oList ) )  //if list is not empty
        deleteList( oList );
 
    oList.head = NULL;  //head and tail are NULL
    oList.tail = oList.head;
}
 
//*************************************************************
/*Add element to the end of the list*/
//by default element inserts to the end of the list
//true - tail of the list; false - head of the list
 
void addElem( lList& oList, unsigned int iData, bool insEnd = true )
{
    if( isEmpty( oList ) )  //if list if empty then first element is a head
    {
        oList.head = new lItem();  //new element
        oList.head->data = iData;  //fill data
        oList.head->next = oList.tail;   //fill next element
        oList.tail = oList.head;  //tail of the list is a head, cause there is just only one element in list
        oList.tail->next = oList.head;   //next element of the tail is a head, cause we have a cycle thru head
    }else  //else if there are elements in the list
    {
        lItem* tmp;  //new element
        tmp = new lItem();
        tmp->data = iData;  //fill data of the element
        tmp->next = oList.head;
 
        if( insEnd )  //if insert to the end
        {
            oList.tail->next = tmp;  //insert element to the end of the list
            oList.tail = tmp;  //this element is the tail
        }else  //else insert to the head of the list
        {
            oList.head = tmp;
            oList.tail->next = oList.head;
        }
    }
}
 
//*************************************************************
/*Print list to the screen*/
 
void printList( lList& oList )
{
    lItem* tmp = oList.head;  //temp element
 
    do
    {
        cout << tmp->data << " ";
        tmp = tmp->next;  //go to the next element
    }while( tmp != oList.head );  //print all other elements to the screen
 
    cout << "\n";
}
 
//*************************************************************
/*Delete element from the head or the tail of the list*/
 
void delElem( lList& oList, bool delHead = false )
{
    lItem* tmp;
 
    if( delHead )
    {
        tmp = oList.head;
        oList.head = oList.head->next;
        oList.tail->next = oList.head;
        delete tmp;
    }else
    {
        tmp = oList.head;
        while( tmp->next != oList.tail )
        {
            tmp = tmp->next;
        }
 
        delete oList.tail;
        tmp->next = oList.head;
        oList.tail = tmp;
    }
}
 
//*************************************************************
/*Prints menu to the screen*/
 
void printMenu()
{
    cout << "1. Add to the head\n";
    cout << "2. Add to the tail\n";
    cout << "3. Delete element from the head\n";
    cout << "4. Delete element from the tail\n";
    cout << "5. Print list to the screen\n";
    cout << "6. Move items\n";
    cout << "7. Insert item\n";
    cout << "0. Exit\n";
    cout << "Enter your choice: ";
}
 
//*************************************************************
/*Moves elements to the new list*/
 
void moveElements()
{
    lList tList;
    //initList( tList );
    tList.head = NULL;
    tList.tail = NULL;
 
    lItem* tmp = mList.head;
 
    int c = 1;
 
    do
    {
        if( c%2 != 0 )
        {
            addElem( tList, tmp->data, true );
        }
        c++;
        tmp = tmp->next;
    }while( tmp != mList.head );
 
    printList( tList );
    deleteList( tList );
}
 
//*************************************************************
/*Add new item after selected*/
 
void insertItem( unsigned int num )
{
    lItem* tmp = mList.head;
 
    do
    {
        if( tmp->data == num )
        {
            lItem* tmp1 = new lItem;
            tmp1->data = 666;
            tmp1->next = tmp->next;
            tmp->next = tmp1;
 
            break;
        }
        tmp = tmp->next;
    }while( tmp != mList.head );
}
 
//*************************************************************
 
int main()
{
    initList( mList );  //initialize list
 
    for( int i = 0; i < 10; i++ )  //fill list with elements 0..9
        addElem( mList, i, true );
 
    unsigned int u_choice = 9;  //user choice
 
    while( u_choice != 0 )  //while choice != 9(e.g. exit)
    {
        printMenu();  //print menu to the list
        cin >> u_choice;  //wait for the user choice
        cout << "\n";
 
        switch( u_choice )
        {
            case 1:  //Add to the head
            {
                unsigned int el = 500;
                addElem( mList, el, false );
                break;
            }
            case 2:  //Add to the tail
            {
                unsigned int el = 600;
                addElem( mList, el, true );
                break;
            }
            case 3:  //Delete element from the head
            {
                delElem( mList, true );  //delete from the head of the list
                break;
            }
            case 4:  //Delete element from the tail
            {
                delElem( mList, false );  //delete from the tail of the list
                break;
            }
            case 5:  //Print list to the screen
            {
                printList( mList );
                break;
            }
            case 6:
            {
                moveElements();
                break;
            }
            case 7:
            {
                int num;
                cout << "Enter data value: ";
                cin >> num;
                insertItem( num );
            }
            case 0: break;  //Exit
        }
    }
 
    deleteList( mList );  //delete list from the memory
    return 0;
}

@pigah · 13.10.2009, 01:18

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
#pragma once
 
 
template <class T>
struct listEl{
  T data;
  listEl<T> *pNext,*pPrev;
  listEl(T d):data(d),pNext(0),pPrev(0)
  {}
};
template <class T>
class list{
  listEl<T>*pHead,*pTeil;
  int N;
public:
  list();
  list(list<T> &b);
  void addToHead(T d);
  void addToTeil(T d);
  void printHead();
  void printTeil();
  void print();
  bool delHead();
  bool delTeil();
  bool deleteCentreElem(int pos);
  int getN();
  list&operator()(int pos);
  void operator()(int pos,T dan);
  T& operator[](int pos);
  list<T>& operator=(list<T> &b);
  list<T>&operator+=(list<T>&ob);
  ~list(void);
};
template <class T>
list<T>::~list(void){
  delHead();
}
template <class T>
list<T>::list():pHead(0),N(0),pTeil(0)
  { }
template <class T>
list<T>::list(list<T> &b):N(0),pHead(0),pTeil(0) {
    listEl<T>*p=b.pHead;    
    while (p){
      this->addToTeil(p->data); 
      p=p->pNext;              
    }     
  }
template <class T>
void list<T>::addToHead(T d){
    listEl<T>*pNew=new listEl<T>(d);
    if(pHead==NULL){
      pHead=pTeil=pNew;
      N++;
      return;
    }
    pNew->pNext=pHead;
    pNew->pPrev=0;//pHead->pPrev;
    pHead->pPrev=pNew;
    pHead=pNew;
    N++;
 }
template <class T>
void list<T>::addToTeil(T d){
    listEl<T>*pNew=new listEl<T>(d);
    if(pHead==NULL){
      pHead=pTeil=pNew;
      N++;
      return;
    }
    pNew->pPrev=pTeil;
    pNew->pNext=0;//pHead->pPrev;
    pTeil->pNext=pNew;
    pTeil=pNew;
    N++;
}
template <class T>
void list<T>::printHead(){
  listEl<T>*p=pHead;
   if(p==NULL){
      cout<<"ошибка: список пуст!!!\n";
      return;
    }
  while(p){
    cout<<p->data<<"\t";
    p=p->pNext;
  }
}
template <class T>
void list<T>::printTeil(){
  listEl<T>*p=pTeil;
   if(p==NULL){
      cout<<"ошибка: список пуст!!!\n";
      return;
    }
  while(p){
    cout<<p->data<<"\t";
    p=p->pPrev;
  }
}
template <class T>
void list<T>::print(){
  listEl<T>*p=pHead;
  listEl<T>*p2=pTeil;
  if(p==pTeil==NULL){
      cout<<"ошибка: список пуст!!!\n";
      return;
    }
  while(p){
    cout<<p->data<<"\t";
    p=p->pNext;
  }  
  cout<<"\n";
  while(p2){
    cout<<p2->data<<"\t";
    p2=p2->pPrev;
  }  
}
template <class T>
  bool list<T>::delHead(){
    listEl<T>*p=pHead;
    listEl<T>*r=pTeil;
    if(N==1){delete pHead;pHead=pTeil=0;N=0;return 1;}
    if(p==NULL&&r==NULL)
      return 0;
    else{
      pHead=p->pNext;
      pHead->pPrev=0;
      delete p;
      N--;
      return 1;
    }
  }
template <class T>
bool list<T>::delTeil(){
    listEl<T>*p=pHead;
    listEl<T>*r=pTeil;
    if(N==1){delete pHead;pHead=pTeil=0;N=0;return 1;}
    if(p==NULL&&r==NULL)
      return 0;
    else{
      pTeil=r->pPrev;
      pTeil->pNext=0;
      delete r;
      N--;
      return 1;
    }
  }
template <class T>
 bool list<T>::deleteCentreElem(int pos){
     listEl<T>*p=this->pHead,*p1;
     if(pHead==NULL)return false;
     if(pos>=N-1)return this->delTeil();
     if(pos<1)return this->delHead();
     if(N==1){delete pHead;pHead=pTeil=0;N=0;return 1;}
     while(--pos)p=p->pNext;//поиск удаляемого объекта р1-удаляемый объект
     p1=p->pNext;
     p->pNext=p1->pNext;
     p=p->pNext;
     p->pPrev=p1->pPrev;
     delete p1;
     N--;
     return true;
   }
template <class T>
int list<T>::getN(){return N;}
template <class T>
T& list<T>::operator[](int pos){
  listEl<T>*p=this->pHead;
  while(--pos)p=p->pNext;
  return p->data;
}
template <class T>
void list<T>::operator()(int pos,T dan){
     (*this)[pos]=dan;
   }
template <class T>
list<T>&list<T>::operator()(int d){
     listEl<T>*p=pHead;
     while(p){
       p->data=d;
       p=p->pNext;
     }
     return *this;
   }
template <class T>
list<T>& list<T>::operator=(list<T> &b){
    if(this!=&b){      
      (*this).list<T>::~list();
      (*this).list<T>::list(b);
    }
    return *this;
   }
template <class T>
list<T>&list<T>::operator+=(list<T>&ob){
     listEl<T>*p=ob.pTeil;
     while(p){
       this->addToHead(p->data);
       p=p->pPrev;
        }
        return(*this);
}

@kravam · 13.10.2009, 01:39

Отталкивают термины и моё незнание английского языка.
А так ничё страшного.

Что значит зацикиливание через голову?
Ну, то есть я понял, что в поле next последнего элемента заносишь адрес первого и всё, зацикливание произошло. Правильно?

Удаление с освобождением памяти- то есть просто в поле next некоторого элемента заносишь адрес элемента типа lItem. но не тот, что был, а другой.
Несколько элементов, таким образом, оказываются вычеркнутыми из списка, память под них освобождаешь delet, так?

Теперь по заданиям.

"Поменять местами первый и последний узлы"
Следи за мыслью.
Коль скоро список зациклен, первый последний элементы в нём условны. Первым считаем тот элемент, который был хвост до зацикливания, а последний, тот который был голова до зацикливания.
Так?
И сразу же: что значит в данном контексте поменять местами?
1) Адреса их мы поменять не можем. Они постоянны на протяжении всей программы.
2) Остаётся менять значения.

Я думаю, поменять значения полей data для тебя не составит труда

Да, собственно, и значения полей next тоже поменять нетрудно. Берёшь да меняешь. Только это уже будет связный списокиз менбьшего количества элементов (хвост выпадет из списка), а тот, что хвост в поле next будет содержать адрес самого себя.

Давай пока с вышенаписанным разберёмся.

Обошёлся бы кодом, да в английском не волоку.

@Опа!! · 13.10.2009, 12:23 **[ТС]**

Зацикливание через голову реализовано в функции добавления

C++
1
2
3
4
....
oList.tail->next = oList.head;  
//next element of the tail is a head, cause we have a cycle thru head
//cледующий элемент за хвостом голова, таким образом мы имеем зацикливание через голову

Вы правильно поняли.
Далее - удаление с освобождением памяти. Тоже всё верно вроде, реазиловано это в функции deleteList. Пока head не равна tail заносим в tmp следующий за head элемент, удаляем head, новому head присваиваем tmp. Затем удаляем голову (head), а хвосту (tail) присваиваем NULL.

Остальное буду смортеть позже, сейчас уходить надо.

pigah, спасибо за код, попробую разобраться (я с классами еще не знаком)

@Опа!! · 09.12.2009, 02:12 **[ТС]**

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

добавление в хвост-голову
удаление с освобождением памяти
инициализацию
удаление из хвоста-головы
добавление нового узла после узла с заданным значением
перемещение нечетных элементов в другой список

Собственно, все это сделано, кроме последнего пункта. Функция есть (move_elem()), но работает она некорректно (во-первых, не перемещает, а копирует и, во-вторых, в каком-то очень странном порядке она это копирование производит). Прощу помощи!

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
struct lItem
{
    unsigned int data;
    lItem* next;
};
 
struct lList
{
    lItem* head;
    lItem* tail;
};
 
lList mList; //основной список;
lList tList; //вспомогательный список для копирования элементов;
unsigned int pos_number; //переменная исп. функцией insertItem;
 
 
//*************************************************************
//Функция удаления списка
void delList( lList& oList )
{
    while( oList.head != oList.tail )
    {
        lItem* tmp;
        tmp = oList.head->next;
        delete oList.head;
        oList.head = tmp;
    }
 
    delete oList.head;  //удаление head
    oList.tail = NULL;
}
 
//*************************************************************
//Функция выполняет проверку списка на "заполненность"
bool bool_empty( lList& oList )
{
    return (oList.head == NULL);  //возвращает true (1) если список пустой
}
 
//*************************************************************
//Инициализация списка
void initList( lList& oList )
{
    if( !bool_empty( oList ) )  //если лист не пустой
        delList( oList );
 
    oList.head = NULL;  //присваиваем голове и хвосту пустое значение
    oList.tail = oList.head;
}
 
//*************************************************************
//Добавление элемента
void addElem( lList& oList, unsigned int iData, bool insEnd = true )
{
    if( bool_empty( oList ) )  //если илст пустой, то первый элемент - голова
    {
        oList.head = new lItem();  //новый элемент
        oList.head->data = iData;  //заполняем data
        oList.head->next = oList.tail;   //заполняем след. элемент
        oList.tail = oList.head;  //хвост списка - голова, т.о. имеем только 1 элемент в списке;
        oList.tail->next = oList.head;   //следующий за хвостом элемент - голова (зацикливание через голову);
    }else  //если есть еще элементы
    {
        lItem* tmp;  //новый элемент
        tmp = new lItem();
        tmp->data = iData;  //заполняем data для элемента
        tmp->next = oList.head;
 
        if( insEnd )  //если добавляем в конец
        {
            oList.tail->next = tmp;  //добавляем элемент в конец
            oList.tail = tmp;  //этот элемент - хвост
        }else  //иначе - голова
        {
            oList.head = tmp;
            oList.tail->next = oList.head;
        }
    }
}
 
//*************************************************************
//Функции вывода в ListBox1 и ListBox2 списков mList и tList
void printList( lList& oList )
{
    Form1->ListBox1->Clear();
    if(bool_empty(mList) == false) {lItem* tmp = oList.head;
 
    do
    {
     Form1->ListBox1->Items->Add(tmp->data);
     tmp = tmp->next;  //переход к след. элементу
    }while( tmp != oList.head );}  //вывод всех элементов
     else Form1->ListBox1->Items->Add("Ошибка! Cписок пуст!");
}
 
void printList2( lList& oList )
{
    lItem* tmp = oList.head;
    do
    {
     Form1->ListBox2->Items->Add(tmp->data);
     //Form1->Memo1->Lines->Add(tmp->data);
 
     tmp = tmp->next;  //переход к след. элементу
    }while( tmp != oList.head );  //вывод всех элементов
}
 
//*************************************************************
//Функция удаления из хвоста или головы
 
void del_elem( lList& oList, bool delHead = false )
{
    lItem* tmp;
 
    if( delHead )
    {
        tmp = oList.head;
        oList.head = oList.head->next;
        oList.tail->next = oList.head;
        delete tmp;
    }else
    {
        tmp = oList.head;
        while( tmp->next != oList.tail )
        {
            tmp = tmp->next;
        }
 
        delete oList.tail;
        tmp->next = oList.head;
        oList.tail = tmp;
    }
}
 
//*************************************************************
//Функция перемещает нечетные элементы из mList в tList
void move_elem()
{
    tList.head = NULL;
    tList.tail = NULL;
 
    lItem* tmp = mList.head;
 
    int c = 1;
 
    do
    {
        if( c%2 != 0 )
        {
            addElem( tList, tmp->data, false );
        }
        c++;
        tmp = tmp->next;
    }while( tmp != mList.head );
 
    delList( tList );
}
 
//*************************************************************
// Функция добавляет элемент со значением "1000"
// ПОСЛЕ элемента, указанного в Edit1
void insertItem( unsigned int num )
{
    lItem* tmp = mList.head;
 
    do
    {
        if( tmp->data == num )
        {
            lItem* tmp1 = new lItem;
            tmp1->data = 1000;
            tmp1->next = tmp->next;
            tmp->next = tmp1;
 
            break;
        }
        tmp = tmp->next;
    }while( tmp != mList.head );
}

@Опа!! · 09.12.2009, 02:44 **[ТС]**

ах да, вот ихсодники

accept · 09.12.2009, 05:49

Сообщение от Опа!!

перемещение нечетных элементов в другой список

надо хранить указатель на предыдущий элемент, перенос - это копирование и удаление элемента, после удаления текущий указатель делаешь предыдущим, а признак уменьшаешь, как будто не было чётного элемента

@Опа!! · 09.12.2009, 22:43 **[ТС]**

хм, у меня нет явного указателя на предыдущий элемент, это не двусвязный список. вобщем не понял я как это реализовать

для начала бы сошел и правильный алгоритм копирования, ибо текущий рабоает совсем некорретко. во-первых, в странном порядке берет из списка значения (хотя порой действительно только нечетные), во вторых работает не для всякого кол-ва узлов. Если в хеад добавить 1, 5, 10 и 15, то он правильно скорует 1 и 10, но если добавить большее кол-во узлов + узлы в хвост, то начинается неразбериха. Не пойму почему. Вот, сопственно, сама функция:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//*************************************************************
//Функция перемещает нечетные элементы из mList в tList
void move_elem()
{
        tList.head = NULL;
        tList.tail = NULL;
 
        lItem* tmp = mList.head;
 
        int c = 1;
 
        do
        {
                if( c%2 != 0 )
                {
                        addElem( tList, tmp->data, false );
                }
                c++;
                tmp = tmp->next;
        }while( tmp != mList.head );
 
        delList( tList );
}

accept · 10.12.2009, 03:31

Сообщение от Опа!!

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

ну, вот ты сделал tmp, сделай ещё prev и просто следом его пускай

Новые блоги и статьи Все статьи Все блоги /
BOINC: 22 года — и всё ещё работает Programma_Boinc 12.03.2026 BOINC: 22 года — и всё ещё работает Дэвид Андерсон написал ретроспективу. Кратко: в 2001 году он ушёл из United Devices, где был CTO, и за несколько месяцев написал ядро BOINC — клиент, сервер,. . .	SDL3 для Desktop (MinGW): Создаём пустое окно с нуля для 2D-графики на SDL3, Си и C++ 8Observer8 10.03.2026 Содержание блога Финальные проекты на Си и на C++: hello-sdl3-c. zip hello-sdl3-cpp. zip Результат:	Установка CMake и MinGW 13.1 для сборки С и C++ приложений из консоли и из Qt Creator в EXE 8Observer8 10.03.2026 Содержание блога MinGW - это коллекция инструментов для сборки приложений в EXE. CMake - это система сборки приложений. Здесь описаны базовые шаги для старта программирования с помощью CMake и. . .	Как дизайн сайта влияет на конверсию: 7 решений, которые реально повышают заявки Neotwalker 08.03.2026 Многие до сих пор воспринимают дизайн сайта как “красивую оболочку”. На практике всё иначе: дизайн напрямую влияет на то, оставит человек заявку или уйдёт через несколько секунд. Даже если у вас. . .
Модульная разработка через nuget packages DevAlt 07.03.2026 Сложившийся в . Net-среде способ разработки чаще всего предполагает монорепозиторий в котором находятся все исходники. При создании нового решения, мы просто добавляем нужные проекты и имеем. . .	Модульный подход на примере F# DevAlt 06.03.2026 В блоге дяди Боба наткнулся на такое определение: В этой книге («Подход, основанный на вариантах использования») Ивар утверждает, что архитектура программного обеспечения — это структуры,. . .	Управление камерой с помощью скрипта OrbitControls.js на Three.js: Вращение, зум и панорамирование 8Observer8 05.03.2026 Содержание блога Финальная демка в браузере работает на Desktop и мобильных браузерах. Итоговый код: orbit-controls-threejs-js. zip. Сканируйте QR-код на мобильном. Вращайте камеру одним пальцем,. . .	SDL3 для Web (WebAssembly): Синхронизация спрайтов SDL3 и тел Box2D 8Observer8 04.03.2026 Содержание блога Финальная демка в браузере. Итоговый код: finish-sync-physics-sprites-sdl3-c. zip На первой гифке отладочные линии отключены, а на второй включены:. . .

@kravam быдлокодер 1724 / 911 / 106 Регистрация: 04.06.2008 Сообщений: 5,705
	13.10.2009, 01:39
	Отталкивают термины и моё незнание английского языка. А так ничё страшного. Что значит зацикиливание через голову? Ну, то есть я понял, что в поле next последнего элемента заносишь адрес первого и всё, зацикливание произошло. Правильно? Удаление с освобождением памяти- то есть просто в поле next некоторого элемента заносишь адрес элемента типа lItem. но не тот, что был, а другой. Несколько элементов, таким образом, оказываются вычеркнутыми из списка, память под них освобождаешь delet, так? Теперь по заданиям. "Поменять местами первый и последний узлы" Следи за мыслью. Коль скоро список зациклен, первый последний элементы в нём условны. Первым считаем тот элемент, который был хвост до зацикливания, а последний, тот который был голова до зацикливания. Так? И сразу же: что значит в данном контексте поменять местами? 1) Адреса их мы поменять не можем. Они постоянны на протяжении всей программы. 2) Остаётся менять значения. Я думаю, поменять значения полей data для тебя не составит труда Да, собственно, и значения полей next тоже поменять нетрудно. Берёшь да меняешь. Только это уже будет связный списокиз менбьшего количества элементов (хвост выпадет из списка), а тот, что хвост в поле next будет содержать адрес самого себя. Давай пока с вышенаписанным разберёмся. Обошёлся бы кодом, да в английском не волоку. 1