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

Динамический список динамических списков - C++

Восстановить пароль Регистрация
 
Рейтинг: Рейтинг темы: голосов - 11, средняя оценка - 4.64
viktorrrr
42 / 42 / 1
Регистрация: 11.02.2010
Сообщений: 358
01.06.2011, 22:28     Динамический список динамических списков #1
Всем экспертам привет. Нужна категорическая помощь). Задача такая, надо разобраться как работает этот код(Заголовочный файл). Комментарии написать. Самому толку не хватает. А уж потом в main() я бы уже сам как-нить засунул. Помогите, пожалуйста

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
266
267
268
269
270
271
272
273
274
#ifndef _UTIL_LIST_H_
#define _UTIL_LIST_H_
 
namespace Core {
 
class EList {
public:
    class Node;
    class IteratorBase;
    class ConstIterator;
    class Iterator;
 
    class Node {
        friend class EList;
        friend class IteratorBase;
 
        Node* next;
        Node* prev;
 
        Node(Node* self) : next(self), prev(self) {}
 
        Node* insert_before(Node* n);
        Node* insert_after(Node* n);
 
        Node* insert_before(EList&);
        Node* insert_after(EList&);
 
    public:
        Node() : next(0), prev(0) {}
        ~Node() { remove_from_list(); }
 
        Node* remove_from_list();
        bool is_in_list() const { return next!=0; }
    };
 
    class IteratorBase {
        typedef IteratorBase self_t;
    protected:
        Node* m_node;
 
        IteratorBase(Node* n) : m_node(n) {}
 
        self_t& inc() { m_node = m_node->next; return *this; }
        self_t& dec() { m_node = m_node->prev; return *this; }
 
        bool eq(const self_t& i) const { return m_node==i.m_node; }
        bool ne(const self_t& i) const { return m_node!=i.m_node; }
 
        Node* insert_before(Node* n) { return m_node->insert_before(n); }
        Node* insert_after(Node* n) { return m_node->insert_after(n); }
 
        Node* insert_before(EList& d) { return m_node->insert_before(d); }
        Node* insert_after(EList& d) { return m_node->insert_after(d); }
 
        Node* do_remove() { return m_node->remove_from_list(); }
    };
 
    class ConstIterator : public IteratorBase {
        typedef IteratorBase base_t;
        typedef ConstIterator self_t;
    public:
        ConstIterator(const Node* n) : base_t(const_cast<Node*>(n)) {}
 
        Node* node() const { return m_node; }
        const Node* operator->() const { return m_node; }
 
        self_t& operator++() { return static_cast<self_t&>(base_t::inc()); }
        self_t& operator--() { return static_cast<self_t&>(base_t::dec()); }
 
        bool operator == (const self_t& i) const { return base_t::eq(i); }
        bool operator != (const self_t& i) const { return base_t::ne(i); }
    };
 
    class Iterator : public ConstIterator {
        typedef ConstIterator base_t;
        typedef Iterator self_t;
    public:
        Iterator(Node* n) : base_t(n) {}
 
        Node* operator->() const { return m_node; }
 
        self_t& operator++() { return static_cast<self_t&>(base_t::inc()); }
        self_t& operator--() { return static_cast<self_t&>(base_t::dec()); }
 
        Iterator insert_before(Node* n) { return base_t::insert_before(n); }
        Iterator insert_after(Node* n) { return base_t::insert_after(n); }
 
        Iterator insert_before(EList& d) { return base_t::insert_before(d); }
        Iterator insert_after(EList& d) { return base_t::insert_after(d); }
 
        Node* remove() { return base_t::do_remove(); }
    };
 
    friend class Node;
 
    bool empty() const { return m_list.next == &m_list; }
 
    ConstIterator front() const { return m_list.next; }
    ConstIterator end() const { return &m_list; }
    ConstIterator back() const { return m_list.prev; }
 
    Iterator front() { return m_list.next; }
    Iterator end() { return &m_list; }
    Iterator back() { return m_list.prev; }
 
    Iterator push_front(Node* n) { return front().insert_before(n); }
    Iterator push_back(Node* n) { return back().insert_after(n); }
    Node* pop_front() { return front().remove(); }
    Node* pop_back() { return back().remove(); }
 
    void clear() { Iterator i=front(); while( i!=end() ) { Iterator e = i; ++i; e.remove(); } }
 
protected:
    EList() : m_list(&m_list) {}
    ~EList() { clear(); }
 
    Node m_list;
 
    void reset() { m_list.next = &m_list; m_list.prev = &m_list; }
};
 
 
inline
EList::Node* EList::Node::remove_from_list()
{
    if( next ) {
        next->prev = prev;
        prev->next = next;
        next = 0;
        prev = 0;
    }
    return this;
}
 
 
inline
EList::Node* EList::Node::insert_before(Node* n)
{
    if( n->next == 0 )
    {
        n->next = this;
        n->prev = prev;
        prev->next = n;
        prev = n;
    }
    return this->prev;
}
 
inline
EList::Node* EList::Node::insert_after(Node* n)
{
    if( n->next == 0 )
    {
        n->next = next;
        n->prev = this;
        next->prev = n;
        next = n;
    }
    return next;
}
 
 
inline
EList::Node* EList::Node::insert_before(EList& list)
{
    if( !list.empty() )
    {
        Node* head = list.m_list.next;
        Node* tail = list.m_list.prev;
        head->prev = prev;
        prev->next = head;
        tail->next = this;
        this->prev = tail;
        list.reset();
        return head;
    }
    return this;
}
 
inline
EList::Node* EList::Node::insert_after(EList& list)
{
    if( !list.empty() )
    {
        Node* head = list.m_list.next;
        Node* tail = list.m_list.prev;
        tail->next = next;
        next->prev = tail;
        head->prev = this;
        this->next = head;
        list.reset();
        return head;
    }
    return next;
}
 
 
 
template<class T>
class EListOf : private EList {
    typedef EList base_t;
public:
    class ConstIterator;
    class Iterator;
 
    friend class ConstIterator;
    friend class Iterator;
 
    class ConstIterator : protected EList::IteratorBase {
        friend class EListOf<T>;
        typedef EList::IteratorBase base_t;
        typedef ConstIterator self_t;
    protected:
        ConstIterator(const EList::IteratorBase& i) : base_t(i) {}
    public:
        ConstIterator(const T* n) : base_t(const_cast<T*>(n)) {}
 
        const T& operator*() const { return *static_cast<const T*>(m_node); }
        const T* operator->() const { return static_cast<const T*>(m_node); }
        self_t& operator++() { return static_cast<self_t&>(base_t::inc()); }
        self_t& operator--() { return static_cast<self_t&>(base_t::dec()); }
 
        bool operator==(const ConstIterator& i) { return base_t::eq(i);}
        bool operator!=(const ConstIterator& i) { return base_t::ne(i);}
    };
 
    class Iterator : public ConstIterator {
        friend class EListOf<T>;
        typedef ConstIterator base_t;
        typedef Iterator self_t;
 
        Iterator(const EList::IteratorBase& i) : base_t(i) {}
    public:
        Iterator(T* n) : base_t(n) {}
 
        T& operator*() const { return *static_cast<T*>(m_node); }
        T* operator->() const { return static_cast<T*>(m_node); }
        self_t& operator++() { return static_cast<self_t&>(base_t::inc()); }
        self_t& operator--() { return static_cast<self_t&>(base_t::dec()); }
 
        self_t insert_before(T* n) { return static_cast<T*>(base_t::insert_before(n)); }
        self_t insert_after(T* n) { return static_cast<T*>(base_t::insert_after(n)); }
 
        self_t insert_before(EListOf<T>& d) { return static_cast<T*>(base_t::insert_before(d)); }
        self_t insert_after(EListOf<T>& d) { return static_cast<T*>(base_t::insert_after(d)); }
 
        T* remove() { return static_cast<T*>(base_t::do_remove()); }
    };
 
    EListOf() {}
    ~EListOf() {}
 
    using EList::empty;
    using EList::clear;
 
    ConstIterator front() const { return base_t::front(); }
    ConstIterator end() const { return base_t::end(); }
    ConstIterator back() const { return base_t::back(); }
 
    Iterator front() { return base_t::front(); }
    Iterator end() { return base_t::end(); }
    Iterator back() { return base_t::back(); }
 
    Iterator push_front(T* n) { return front().insert_before(n); }
    Iterator push_back(T* n) { return back().insert_after(n); }
    T* pop_front() { return front().remove(); }
    T* pop_back() { return back().remove(); }
 
};
 
 
}
 
#endif
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
01.06.2011, 22:28     Динамический список динамических списков
Посмотрите здесь:

C++ Программная реализация динамического списка динамических списков
C++ Стек-массив динамических списков
C++ Даны два динамических массива размерами n и m. Создать динамический массив из заданных, путем их объединения.
C++ Список списков)
Программирование динамических списков C++
Список списков C++
C++ Сформировать динамический массив, состоящий из динамических строк
C++ Динамический массив динамических объектов

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

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
taras atavin
Ушёл с форума.
 Аватар для taras atavin
3569 / 1752 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
02.06.2011, 08:21     Динамический список динамических списков #2
viktorrrr, а зачем нужен списков списков? Для двумерности по аналогии с массивом массивов?
viktorrrr
42 / 42 / 1
Регистрация: 11.02.2010
Сообщений: 358
02.06.2011, 21:40  [ТС]     Динамический список динамических списков #3
Цитата Сообщение от taras atavin Посмотреть сообщение
viktorrrr, а зачем нужен списков списков? Для двумерности по аналогии с массивом массивов?

Я тоже, кстати, не понимаю). Но мне препод дал такое задание). Могу, если че, задание скинуть) . Плюс еще у меня есть код рабочий динамического списка. Вот никак туда подсписок тоже воткнуть мозгов не хватает. Если есть возможность помочь, могу все подробно расскзать и обяснить)

Добавлено через 6 часов 6 минут
Это есть заголовочный файл.


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
#ifndef MYNEWLIST_H
#define MYNEWLIST_H
using namespace std;
struct LIST {
 
    int info;
    LIST *next;
    
};
 
struct  LISTpod{                   //обявление подсписка
    float infoP;
    LISTpod *nextP;              //Нигде в программе на данный момент не включено
 
};
 
 
class myList{
public:
    void Initial()    // Начальные значения НУЛЛ. Указатель
{
    
    head = new LIST;
    head->next=NULL;                      //Указатель на следующий элемент списка обнуляемс
 
}
    //===================================
    bool Empty()
{
    if (head->next==NULL)  //Если список пуст
    return 1;
    else
    return 0;
}
 
    LIST *Search(int num)
{
    
    Prev=head;
    LIST *tmp=head->next;
    while(tmp!=NULL && tmp->info!=num)
    {
    Prev=tmp;
    tmp=tmp->next;
    }
    return tmp;
    cout<<tmp;
 
}
 
    //====================================
    int Del(int num)
{
 
    LIST *current=Search(num);
    if (current!=NULL)
    {
    Prev->next=current->next;
    delete current;
    return 1;
    }
    return 0;
 
}
    //==============================================
    void Show()
{
 
    LIST *tmp=head->next;
    cout<< endl << "Элементы списка:" << endl;
    while(tmp!=NULL)
    {
    cout << tmp->info << " ";
    tmp=tmp->next;
    }
    cout << endl;
 
}
 
    //==================================================
    int AddAfter(int num, int point)
{
 
    if (Empty()==1)
    {
    LIST *tmp=new LIST;
    head->next=tmp;
    tmp->info=num;
    tmp->next=NULL;
    return 1;
    }
    LIST *current=Search(point);
    if(current!=NULL)
    {
    LIST *tmp=new LIST;
    tmp->next=current->next;
    current->next=tmp;
    tmp->info=num;
    return 1;
    }
    return 0;
 
}
 
    //=======================================================
    void DelAll()
{
 
    LIST *tmp;
    while(head->next!=NULL)
    {
    tmp=head;
    head=head->next;
    delete tmp;
    }
 
}
    //====================================
    bool AddBefore(int num, int point)
{
 
    LIST *current=Search(point);
    if (current!=0)
    {
    LIST *tmp=new LIST;
    Prev->next=tmp;
    tmp->next=current;
    tmp->info=num;
    return true;
    }
    return false;
 
}
 
private:
    LIST *head,*Prev;
};
 
 
class myListfloat{
public:
    void Initial()    // Начальные значения НУЛЛ. Указатель
{
 
    head = new LIST;
    head->next=NULL;                      //Указатель на следующий элемент списка обнуляемс
 
}
    //===================================
    bool Empty()
{
    if (head->next==NULL)
    return 1;
    else
    return 0;
}
 
    LIST *Search(int num)
{
 
    Prev=head;
    LIST *tmp=head->next;
    while(tmp!=NULL && tmp->info!=num)
    {
    Prev=tmp;
    tmp=tmp->next;
    }
    return tmp;
    
 
}
 
    //====================================
    int Del(int num)
{
 
    LIST *current=Search(num);
    if (current!=NULL)
    {
    Prev->next=current->next;
    delete current;
    return 1;
    }
    return 0;
 
}
    //==============================================
    void Show()
{
 
    LIST *tmp=head->next;
    cout<< endl << "Элементы списка:" << endl;
    while(tmp!=NULL)
    {
    cout << tmp->info << " ";
    tmp=tmp->next;
    }
    cout << endl;
 
}
 
    //==================================================
    int AddAfter(int num, int point)
{
 
    if (Empty()==1)
    {
    LIST *tmp=new LIST;
    head->next=tmp;
    tmp->info=num;
    tmp->next=NULL;
    return 1;
    }
    LIST *current=Search(point);
    if(current!=NULL)
    {
    LIST *tmp=new LIST;
    tmp->next=current->next;
    current->next=tmp;
    tmp->info=num;
    return 1;
    }
    return 0;
 
}
 
    //=======================================================
    void DelAll()
{
 
    LIST *tmp;
    while(head->next!=NULL)
    {
    tmp=head;
    head=head->next;
    delete tmp;
    }
 
}
    //====================================
    bool AddBefore(int num, int point)
{
 
    LIST *current=Search(point);
    if (current!=0)
    {
    LIST *tmp=new LIST;
    Prev->next=tmp;
    tmp->next=current;
    tmp->info=num;
    return true;
    }
    return false;
 
}
 
private:
    LIST *head,*Prev;
    LIST *headp;
};
#endif


Соббсно, исполняемая часть
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
#include<iostream>
#include"mynewList.h"
 
using namespace std;
 
int main()
{
    system("cls");   //очищение окна консоли
 
    setlocale(LC_ALL,"Russian");
    myList *l=new myList;
    l->Initial();
    int num,point;
    char otv,otv2;
    do
    {
 
       cout << "1. Добавление в основной список" << endl
           <<"2 Начать заполнять подсписок чисел с плавающей запятой"<<endl
        << "3. Удаление" << endl
        << "4. Вывод списка" << endl
        << "0. Выход" << endl
        << " = ";
        cin >> otv;
        switch(otv)
        {
        case '1':
            //добавление элемента в список основной, если основной список пустой
            //Нельзя добавить
 
 
 
            cout << endl << "Введите Номер списка = ";
            cin >> num;
            if (l->Empty()==1)
                l->AddAfter(num,0);
            
            //================================================
            //=================================================
            //ЦИКЛ для заполнения подсписка
 
 
 
 
            //==========================================================
            //=========================================================
            else
 
            {
 
                cout << endl << "1. Добавить перед" << endl
                << "2. Добавить после" << endl
                << " = ";
                cin >> otv2;
                switch(otv2)
                {
                case '1':
 
                    cout << endl << "Перед каким элементом добавить = ";
                    cin >> point;
                    if (l->AddBefore(num,point)==1)
                    cout << endl << "Элемент добавлен в список" << endl;
                    else
                    cout << endl << "Такого элемента не существует" << endl;
                    break;
 
                case '2':
 
                    cout << endl << "После какого элемента добавить = ";
                    cin >> point;
                    if (l->AddAfter(num,point)==1)
                    cout << endl << "Элемент добавлен в список" << endl;
                    else
                    cout << endl << "Такого элемента не существует" << endl;
                    break;
 
                default:
 
                    cout << endl << "Ошибка" << endl;
                    break;
 
                }
 
            }
            break;
 
        case '3':
 
            if (l->Empty()==1)
            cout << endl << "Список пуст" << endl;
            else
            {
            cout << endl << "Удаляемый элемент = ";
            cin >> num;
            if (l->Del(num)==1)
            cout << endl << "Элемент удален" << endl;
            else
            cout << endl << "Такого элемента не существует" << endl;
            }
            break;
 
        case '4':
 
            if (l->Empty()==1)
            cout << endl << "Список пуст" << endl;
            else
                l->Show();
            break;
        case '5':
            cout<<"Введите искомый элемент"<<endl;   //поиск элемента
            cin>>num;
            if(l->Empty()==1)   
                cout<<"Список пуст"<<endl;
            else
                l->Search(num);
            cout<<l->Search(num);
            
            break;
            
 
        case '0':
        
 
            l->DelAll();
            break;
 
        default:
 
            cout << endl << "Ошибка" << endl;
            break;
 
        }
 
    }while(otv!='0');
    delete l; //освобождаем память
    cin.get(); //Ожидаем нажатия клавиши любой
 
}


Вот как вот в этот список включить подсписок??
Программ должна работать следующим образом
1) Нажмите цифру 1, шоб забить первый элемент списка
// Тока мы эту цифру забили, т.е первый элемент основного списка, новый цикл должне вызваться для заполнения подсписка(к примеру, вещественных чисел) . Ну, конечно, должны быть доступны все стандартные операции со списком.
//Заканчиваем работу с подсписком, снова выходит к нам цикл основного списка(1)Введите номер списка(к примеру 2 вводим) и повторяется прежняя операция с подсписком вещественных чисел.


Ну и , конечно, при удалении элемента основного списка, должен удаляться и подсписок. Ну, думаю, тут проблем возникнуть не должно, если стабильно будет работать подсписок.


Помогите!!!!! Очччень надо. Список выше рабочий.
Не смогу это сделать, придется кучу бабок платить за пересдачу, возможно, не одну((((. Буду глубоко благдарен
Yandex
Объявления
02.06.2011, 21:40     Динамический список динамических списков
Ответ Создать тему
Опции темы

Текущее время: 00:48. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru