Форум программистов, компьютерный форум CyberForum.ru

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
Рейтинг: Рейтинг темы: голосов - 16, средняя оценка - 4.63
Опа!!
15 / 15 / 0
Регистрация: 30.09.2009
Сообщений: 89
#1

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

13.10.2009, 00:24. Просмотров 2248. Ответов 8
Метки нет (Все метки)

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

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

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

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

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;
}
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
13.10.2009, 00:24
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Список с указателем на последний элемент (C++):

односвязный список не вставляет последний элемент - C++
крашит при вставке последнего( с остальными вроде все норм #include&lt;iostream&gt; using namespace std; struct A { int key; }; ...

Односвязный список: удалить последний элемент равный 0 - C++
Удалить последний элемент однонаправленного списка равный 0.

В односвязный список добавляется последний нулевой элемент - C++
Здравствуйте, такая проблема, почему-то в список добавляется последний нулевой элемент, в чем может быть трабл ? скрин Вот...

Создать динамический список. Удалить из него первый и последний элемент. - C++
Список. есть пример программы: Создать динамический список. Удалить из него первый и последний элемент. #include &lt;iostream.h&gt; ...

Вывести содержимое списка в следующем порядке: первый элемент, последний элемент, второй элемент, предпоследни - C++
#include &lt;iostream&gt; #include &lt;list&gt; #include &lt;iterator&gt; void output(std::list&lt;int&gt; myList, std::list&lt;int&gt;::iterator iter1,...

Строки. Как найти в слове первый элемент? Второй элемент, последний элемент? - C++
как найти в слове первый элемент?Второй элемент,последний элемент.С помощью каких операторов это делается??

Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
pigah
12 / 12 / 2
Регистрация: 05.07.2009
Сообщений: 147
Записей в блоге: 1
13.10.2009, 01:18 #2
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
быдлокодер
1694 / 881 / 44
Регистрация: 04.06.2008
Сообщений: 5,441
13.10.2009, 01:39 #3
Отталкивают термины и моё незнание английского языка.
А так ничё страшного.

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

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

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

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

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

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


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

Обошёлся бы кодом, да в английском не волоку.
Опа!!
15 / 15 / 0
Регистрация: 30.09.2009
Сообщений: 89
13.10.2009, 12:23  [ТС] #4
Зацикливание через голову реализовано в функции добавления
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, спасибо за код, попробую разобраться (я с классами еще не знаком)
Опа!!
15 / 15 / 0
Регистрация: 30.09.2009
Сообщений: 89
09.12.2009, 02:12  [ТС] #5
с предыдущим разобрался, возникла необходимость еще 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 );
}
Опа!!
15 / 15 / 0
Регистрация: 30.09.2009
Сообщений: 89
09.12.2009, 02:44  [ТС] #6
ах да, вот ихсодники
Вложения
Тип файла: rar односвязные списки.rar (3.83 Мб, 33 просмотров)
accept
4821 / 3241 / 165
Регистрация: 10.12.2008
Сообщений: 10,682
09.12.2009, 05:49 #7
Цитата Сообщение от Опа!!
перемещение нечетных элементов в другой список
надо хранить указатель на предыдущий элемент, перенос - это копирование и удаление элемента, после удаления текущий указатель делаешь предыдущим, а признак уменьшаешь, как будто не было чётного элемента
Опа!!
15 / 15 / 0
Регистрация: 30.09.2009
Сообщений: 89
09.12.2009, 22:43  [ТС] #8
хм, у меня нет явного указателя на предыдущий элемент, это не двусвязный список. вобщем не понял я как это реализовать

для начала бы сошел и правильный алгоритм копирования, ибо текущий рабоает совсем некорретко. во-первых, в странном порядке берет из списка значения (хотя порой действительно только нечетные), во вторых работает не для всякого кол-ва узлов. Если в хеад добавить 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
4821 / 3241 / 165
Регистрация: 10.12.2008
Сообщений: 10,682
10.12.2009, 03:31 #9
Цитата Сообщение от Опа!!
хм, у меня нет явного указателя на предыдущий элемент
ну, вот ты сделал tmp, сделай ещё prev и просто следом его пускай
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
10.12.2009, 03:31
Привет! Вот еще темы с ответами:

Проблема с указателем на элемент вектора - C++
Всем доброго времени суток. Не могу никак выкрутиться) Допустим, у нас есть класс &quot;А&quot; с параметрами: std::vector &lt;TNode*&gt; nodes; И...

В чем разница между указателем и указателем на указатель? - C++
int x, *p, *q; x=10; p=&amp;x; q=p; cout&lt;&lt;*q; int x, *p, **q; x=10; p=&amp;x; q=&amp;p;

Как добавить элемент в очередь, используя указатель на последний элемент? - C++
Не пойму как добавить элемент в очередь используя указатель на последний элемент. Выполняю задание из книги М Доусона с++ и вот реализовать...

Найти максимальный элемент массива и вывести последний четный элемент - C++
Короче нужно чтобы програма нашла максимальный елемент масива и выводила на екран последное четное число масива #include&lt;iostream&gt; ...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
Yandex
Объявления
10.12.2009, 03:31
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru