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

@Опа!! · Регистрация: 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 и просто следом его пускай

Новые блоги и статьи Все статьи Все блоги /
Thinkpad X220 Tablet — это лучший бюджетный ноутбук для учёбы, точка. Programma_Boinc 23.12.2025 Thinkpad X220 Tablet — это лучший бюджетный ноутбук для учёбы, точка. Рецензия / Мнение/ Перевод Сайт называется reddit: The Thinkpad X220 Tablet is the best budget school laptop period. Это. . .	PhpStorm 2025.3: WSL Terminal всегда стартует в ~ and_y87 14.12.2025 PhpStorm 2025. 3: WSL Terminal всегда стартует в ~ (home), игнорируя директорию проекта Симптом: После обновления до PhpStorm 2025. 3 встроенный терминал WSL открывается в домашней директории. . .	Как объединить две одинаковые БД Access с разными данными VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.	Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 04.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .
От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .	Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .	Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .	Ломающие изменения в C#.NStar Alpha Etyuhibosecyu 20.11.2025 Уже можно не только тестировать, но и пользоваться C#. NStar - писать оконные приложения, содержащие надписи, кнопки, текстовые поля и даже изображения, например, моя игра "Три в ряд" написана на этом. . .	Мысли в слух kumehtar 18.11.2025 Кстати, совсем недавно имел разговор на тему медитаций с людьми. И обнаружил, что они вообще не понимают что такое медитация и зачем она нужна. Самые базовые вещи. Для них это - когда просто люди. . .

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