429 / 312 / 129
Регистрация: 09.02.2021
Сообщений: 1,096
Записей в блоге: 1
1

Слияние двух односвязных списков

25.11.2021, 01:12. Показов 2850. Ответов 16

Author24 — интернет-сервис помощи студентам
Объединение двух сортированных списков в один сортируемый список. Этот метод должен принимать в качестве аргумента ссылку (или указатель) на List (это список, который нужно объединить со списком этого объекта класса List, от которого был вызван метод) и возвращать ссылку (или указатель) на объединенный список:
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
#include "List.h"
#include <iostream>
 
using namespace std;
 
ListNode* List::getNewNode(const int& value)
{
    ListNode* ptr = new ListNode(value);
    return ptr;
}
 
List::List()
{
    firstPtr = 0;
    lastPtr = 0;
}
 
List::~List()
{
    if (!isEmpty()) {
        cout << "Removing nodes..." << endl;
        ListNode* currentPtr=firstPtr,*tempPtr;
 
        while (currentPtr != 0) {
            tempPtr = currentPtr;
            cout << tempPtr->data << endl;
            currentPtr = currentPtr->nextPtr;
            delete tempPtr;
        }
    }
 
    cout << "List is empty!" << endl;
}
 
bool List::isEmpty() const
{
    return firstPtr==0;
}
 
void List::print() const
{
    if (isEmpty()) {
        cout << "List is empty" << endl;
        return;
    }
    ListNode* currentPtr = firstPtr;
 
    cout << "List consists of: ";
    while (currentPtr != 0) {
        cout << currentPtr->data << " ";
        currentPtr = currentPtr->nextPtr;
    }
    cout << endl;
}
 
void List::insertAtFront(const int& value)
{
    ListNode* newPtr = getNewNode(value);
    if (isEmpty()) {
        firstPtr = lastPtr = newPtr;
    }
    else {
        newPtr->nextPtr = firstPtr;
        firstPtr = newPtr;
    }
}
 
void List::insertAtBack(const int& value)
{
    ListNode* newPtr = getNewNode(value);
    if (isEmpty()) {
        firstPtr = lastPtr = newPtr;
    }
    else {
        lastPtr->nextPtr = newPtr;
        lastPtr = newPtr;
    }
}
 
int List::removeFromFront(int& value)
{
    if (isEmpty()) {
        return 0;
    }
    else {
        ListNode* tempPtr = firstPtr;
        if (firstPtr == lastPtr) {
            firstPtr = 0;
            lastPtr = 0;
        }
        else {
            firstPtr = firstPtr->nextPtr;
        }
        value = tempPtr->data;
        delete tempPtr;
 
        return 1;
    }
}
 
int List::removeFromBack(int& value)
{
    if (isEmpty()) {
        return 0;
    }
    else {
        ListNode* tempPtr = lastPtr;
        if (firstPtr == lastPtr) {
            firstPtr = 0;
            lastPtr = 0;
        }
        else {
            ListNode* currentPtr = firstPtr;
 
            while (currentPtr->nextPtr != lastPtr) {
                currentPtr = currentPtr->nextPtr;
            }
            lastPtr = currentPtr;
            currentPtr->nextPtr = 0;
        }
        value = tempPtr->data;
        delete tempPtr;
 
        return 1;
    }
}
 
void List::sort()
{
    if (isEmpty()) {
        return;
    }
    ListNode* newPtr = firstPtr, * temp= 0;
    for (temp = firstPtr; temp; temp = temp->nextPtr)
    {
        for (newPtr = firstPtr; newPtr ->nextPtr; newPtr = newPtr->nextPtr)
        {
            if (newPtr->data > newPtr->nextPtr->data)
            {
                swap(newPtr->data, newPtr->nextPtr->data);
            }
        }
    }
}
 
ListNode* List::merge(ListNode* ptr)
{
    ListNode* result = firstPtr;
    return result;
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
#include "ListNode.h"
 
ListNode::ListNode(const int& _data)
{
    data = _data;
    nextPtr = 0;
}
 
int ListNode::getData() const
{
    return data;
}
0
Лучшие ответы (1)
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
25.11.2021, 01:12
Ответы с готовыми решениями:

Объединение (конкатенация) двух односвязных списков
Задача: Построить стек (односвязный список). Показать реализацию стека на следующем примере:...

Равенство двух полиномов(односвязных списков)
#include &lt;iostream&gt; #include &lt;fstream&gt; using namespace std; struct Polinom {//структура...

Слияние двух отсортированных списков
Напишите функцию List&amp; merge(List&amp; L1, List&amp; L2), добавляю- щую к упорядоченному списку L1 также...

Слияние двух списков(срочно!)
Даны два списка, нужно их склеить. Вот, написал, но при комплияции выдаются неведомые мне ошибки....

16
429 / 312 / 129
Регистрация: 09.02.2021
Сообщений: 1,096
Записей в блоге: 1
25.11.2021, 18:59  [ТС] 2
C++
1
2
3
4
5
6
7
8
9
10
class ListNode
{
    friend class List;
private:
    int data;
    ListNode* nextPtr;
public:
    ListNode(const int&);
    int getData()const;
};
0
1709 / 1109 / 337
Регистрация: 25.01.2019
Сообщений: 2,910
28.11.2021, 23:57 3
Господа, поднимаю тему, ибо ТС мб от отчаяния лезет в ЛС (видимо очень нужно), а я сейчас бух и строчки в глазах съезжаются.

Кликните здесь для просмотра всего текста
2
matviiv
29.11.2021, 00:00  [ТС]
  #4

Не по теме:

Folian,да отчаяние из-за того что давно не програмирую на с++ а щас стало нужно :)

0
1709 / 1109 / 337
Регистрация: 25.01.2019
Сообщений: 2,910
29.11.2021, 00:08 5
Цитата Сообщение от matviiv Посмотреть сообщение
да отчаяние из-за того что давно не програмирую на с++ а щас стало нужно
Лучше б ты не оправдывался сейчас.
0
429 / 312 / 129
Регистрация: 09.02.2021
Сообщений: 1,096
Записей в блоге: 1
29.11.2021, 00:10  [ТС] 6
Folian, ой извините тогда
0
4817 / 2278 / 287
Регистрация: 01.03.2013
Сообщений: 5,947
Записей в блоге: 28
29.11.2021, 00:15 7
Как Кнута цитировать, так все, а как списки мержить - так никого! Я возмущен, товарищи! (С)

ЗЫ в мутабельном мире бежишь двумя указателями, каждым по своему списку, сравниваешь текущие значения и в зависимости что больше - перевязываешь ссылки на хвосты, отдельно обрабатывая ситуацию равных элементов, и надеясь, что списки никто не зациклил. Как доходишь до конца любого из списков - привязываешь хвост второго в хвост того, чей конец достижен.
1
429 / 312 / 129
Регистрация: 09.02.2021
Сообщений: 1,096
Записей в блоге: 1
29.11.2021, 00:19  [ТС] 8
_Ivana, как мержить я понимаю я не понимаю етот пункт
Цитата Сообщение от matviiv Посмотреть сообщение
объекта класса List, от которого был вызван метод
; P.s: цитата украдена у одного пользователя форума
0
4817 / 2278 / 287
Регистрация: 01.03.2013
Сообщений: 5,947
Записей в блоге: 28
29.11.2021, 00:28 9
Цитата Сообщение от matviiv Посмотреть сообщение
как мержить я понимаю
отлично
Цитата Сообщение от matviiv Посмотреть сообщение
я не понимаю етот пункт
в нормальных языках есть функции, которые принимают аргументы и возвращают результат + мутируют аргументы. В ООП нет функций, есть методы. Если оставить в стороне т.н. статические, или методы класса, то остаются методы экземпляра (ака объекта) - по сути те же функции, неявно принимающие зис (ссылку на объект) своим первым параметорм и позволяющим мутировать объект по ней. В С++ есть и функции и методы (злые языки говорят, что нет методов, а есть функции-члены, но для краткости и благозвучности будем говорить методы). Можете начать с написания просто свободной функции (раз вы знаете и понимаете как ее писать), а потом, чтобы сделать ее методом, достаточно будет вызвать ее в теле метода объекта с параметром-зисом
Цитата Сообщение от matviiv Посмотреть сообщение
цитата украдена у одного пользователя форума
фигасе, Дональд Кнут зареген на этом форуме? Интересно, под каким ником. TheCalligrapher ?
0
429 / 312 / 129
Регистрация: 09.02.2021
Сообщений: 1,096
Записей в блоге: 1
29.11.2021, 01:12  [ТС] 10
_Ivana,
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
List List::merge(List ptr)
{
    List result;
    List* lastPtrRef = &result;
 
    while (1)
    {
        if (ptr.firstPtr == NULL)
        {
            *lastPtrRef->firstPtr = this->firstPtr;
            break;
        }
        else if (this->firstPtr == NULL)
        {
            *lastPtrRef = ptr;
            break;
        }
 
        lastPtrRef = &((*lastPtrRef)->nextPtr);
    }
    return(result);
}
чет не получилось
0
4817 / 2278 / 287
Регистрация: 01.03.2013
Сообщений: 5,947
Записей в блоге: 28
29.11.2021, 01:21 11
Тыж говорил понимаешь как мержить
0
429 / 312 / 129
Регистрация: 09.02.2021
Сообщений: 1,096
Записей в блоге: 1
29.11.2021, 01:22  [ТС] 12
_Ivana, ну когда-то я так мержил
0
4769 / 2579 / 892
Регистрация: 29.11.2010
Сообщений: 5,581
29.11.2021, 02:31 13
Можно упростить конструкцию, написав немного итераторов:

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
#include <iostream>
 
struct NodeBase {
    NodeBase *next;
 
    NodeBase() : next{this} {}
 
    NodeBase(NodeBase *after) : next{after->next} {
        after->next = this;
    }
 
    void remove(NodeBase *previous) {
        previous->next = next;
    }
};
 
template<typename T>
struct Node : public NodeBase {
    T value;
 
    Node(NodeBase *after, const T &value) : NodeBase{after}, value{value} {}
};
 
template<typename T>
class ListIterator {
public:
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = value_type *;
    using reference = value_type &;
 
    ListIterator(NodeBase *node) : node{node} {}
 
    reference operator*() const { return reinterpret_cast<Node<T>*>(node)->value; }
 
    pointer operator->() { return &(reinterpret_cast<Node<T>*>(node)->value); }
 
    // Prefix increment
    ListIterator<T> &operator++() {
        node = node->next;
        return *this;
    }
 
    // Postfix increment
    ListIterator<T> operator++(int) {
        ListIterator<T> result = *this;
        ++(*this);
        return result;
    }
 
    friend bool operator==(const ListIterator<T> &a, const ListIterator<T> &b) { return a.node == b.node; };
 
    friend bool operator!=(const ListIterator<T> &a, const ListIterator<T> &b) { return a.node != b.node; };
private:
    NodeBase *node;
};
 
template<typename T>
struct BackInsertIterator {
    using iterator_category = std::output_iterator_tag;
    using value_type = void;
    using difference_type = ptrdiff_t;
    using pointer = void;
    using reference = void;
 
    BackInsertIterator(NodeBase *prev): prev{prev} {}
 
    BackInsertIterator<T> operator=(const T &value) {
        prev = new Node<T>(prev, value);
    }
 
    BackInsertIterator<T> &operator*() {
        return *this;
    }
 
    BackInsertIterator<T> &operator++() {
        return *this;
    }
 
    BackInsertIterator<T> &operator++(int) {
        return this;
    }
 
    NodeBase *prev;
};
 
template<typename T>
class List {
public:
    using Iterator = ListIterator<T>;
    using ConstIterator = ListIterator<const T>;
 
    List() : base{} {}
 
    List(const List<T> &) = delete;
 
    List<T> &operator=(const List<T> &) = delete;
 
    virtual ~List() {
        clear();
    }
 
    bool isEmpty() const {
        return &base == base.next;
    }
 
    void pushFront(const T &value) {
        new Node<T>(&base, value);
    }
 
    void clear() {
        while (!isEmpty()) {
            NodeBase *current = base.next;
            current->remove(&base);
            delete current;
        }
    }
 
    ConstIterator begin() const {
        return base.next;
    }
    ConstIterator end() const {
        return base.next;
    }
 
    Iterator begin() {
        return base.next;
    }
 
    Iterator end() {
        return &base;
    }
 
    BackInsertIterator<T> getBackInserter() {
        NodeBase *result;
        for (result = base.next; result != &base; result = result->next) {
        }
        return result;
    }
 
private:
    NodeBase base;
};
 
 
// функция, сливающая два отсортированных диапазона в назначение
template<typename IteratorA, typename IteratorB, typename Destination, typename Less>
Destination mergeSorted(IteratorA beginA, IteratorA endA,
                        IteratorB beginB, IteratorB endB, Destination destination, Less isLess = std::less()) {
    // идем по первому рэнжу
    for (; beginA != endA; ++destination) {
        // если второй рэнж закончился
        if (beginB == endB) {
            // добавляем весь остаток первого диапазона в дестинейшон
            // и возвращаем указатель на конец нового диапазона
            return std::copy(beginA, endA, destination);
        }
        // если значение из первого диапазона меньше значения из второго диапазона
        if (isLess(*beginB, *beginA)) {
            // добавляем текущее значение из второго диапазона
            *destination = *beginB; // пост-инкремент итератора может делать лишнее, а то и не существовать
            ++beginB;               // поэтому используем пред-инкремент
        } else {
            // иначе добавляем текущее значение из первого диапазона
            *destination = *beginA;
            ++beginA;
        }
    }
    // а в конце копируем всё оставшееся из второго диапазона и возвращаем указатель на конец нового диапазона
    return std::copy(beginB, endB, destination);
}
 
int main() {
 
    List<int> first;
    List<int> second;
 
    for (int i = 6; i >= 0; ----i) {
        first.pushFront(i);
    }
    for (int i = 15; i >= 0; ------i) {
        second.pushFront(i);
    }
 
    for (auto x : first) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    for (auto x : second) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
 
    List<int> third;
 
    mergeSorted(first.begin(), first.end(), second.begin(), second.end(), third.getBackInserter(), std::less());
    for (auto x : third) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
 
    return 0;
}
1
429 / 312 / 129
Регистрация: 09.02.2021
Сообщений: 1,096
Записей в блоге: 1
29.11.2021, 11:05  [ТС] 14
lemegeton, извините оно не много не сходиться с условием задания
0
4769 / 2579 / 892
Регистрация: 29.11.2010
Сообщений: 5,581
29.11.2021, 14:59 15
Лучший ответ Сообщение было отмечено matviiv как решение

Решение

Цитата Сообщение от matviiv Посмотреть сообщение
lemegeton, извините оно не много не сходиться с условием задания
Я вам концепцию показал, а не решение выдал. Код сырой, с костылями. Разве что для студента и сгодится.
Что именно не сходится с условием задания? Напишите, пожалуйста, полное условие задания.

Цитата Сообщение от matviiv Посмотреть сообщение
Объединение двух сортированных списков в один сортируемый список.
Это как раз и реализовано через итераторы.

Цитата Сообщение от matviiv Посмотреть сообщение
Этот метод должен принимать в качестве аргумента ссылку (или указатель) на List (это список, который нужно объединить со списком этого объекта класса List, от которого был вызван метод) и возвращать ссылку (или указатель) на объединенный список:
Это конкретное указание в задании на то как делать или рекомендация от преподавателя? Явно написано своими словами.

После добавления итераторов, конструктор копирования и оператор присваивания теперь довольно просто написать.
Добавить метод, дёргающий за функцию мержа тоже.
Плюс пофикшено несколько ошибок и внесено несколько новых.
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
#include <iostream>
 
struct NodeBase {
    NodeBase *next;
 
    NodeBase() : next{this} {}
 
    NodeBase(NodeBase *after) : next{after->next} {
        after->next = this;
    }
 
    void remove(NodeBase *previous) {
        previous->next = next;
    }
};
 
template<typename T>
struct Node : public NodeBase {
    T value;
 
    Node(NodeBase *after, const T &value) : NodeBase{after}, value{value} {}
};
 
template<typename T>
class ListIterator {
public:
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = value_type *;
    using reference = value_type &;
 
    ListIterator(NodeBase *node) : node{node} {}
 
    reference operator*() { return reinterpret_cast<Node<T>*>(node)->value; }
    reference operator*() const { return reinterpret_cast<Node<T>*>(node)->value; }
 
    pointer operator->() { return &(reinterpret_cast<Node<T>*>(node)->value); }
    pointer operator->() const { return &(reinterpret_cast<Node<T>*>(node)->value); }
 
    // Prefix increment
    ListIterator<T> &operator++() {
        node = node->next;
        return *this;
    }
 
    // Postfix increment
    ListIterator<T> operator++(int) {
        ListIterator<T> result = *this;
        ++(*this);
        return result;
    }
 
    friend bool operator==(const ListIterator<T> &a, const ListIterator<T> &b) { return a.node == b.node; };
 
    friend bool operator!=(const ListIterator<T> &a, const ListIterator<T> &b) { return a.node != b.node; };
private:
    NodeBase *node;
};
 
template<typename T>
struct BackInsertIterator {
    using iterator_category = std::output_iterator_tag;
    using value_type = void;
    using difference_type = ptrdiff_t;
    using pointer = void;
    using reference = void;
 
    BackInsertIterator(NodeBase *prev): prev{prev} {}
 
    BackInsertIterator<T> operator=(const T &value) {
        prev = new Node<T>(prev, value);
        return *this;
    }
 
    BackInsertIterator<T> &operator*() {
        return *this;
    }
 
    BackInsertIterator<T> &operator++() {
        return *this;
    }
 
    BackInsertIterator<T> &operator++(int) {
        return this;
    }
 
    NodeBase *prev;
};
 
// функция, сливающая два отсортированных диапазона в назначение
template<typename IteratorA, typename IteratorB, typename Destination, typename Less>
Destination mergeSorted(IteratorA beginA, IteratorA endA,
                        IteratorB beginB, IteratorB endB, Destination destination, Less isLess = std::less()) {
    // идем по первому рэнжу
    for (; beginA != endA; ++destination) {
        // если второй рэнж закончился
        if (beginB == endB) {
            // добавляем весь остаток первого диапазона в дестинейшон
            // и возвращаем указатель на конец нового диапазона
            return std::copy(beginA, endA, destination);
        }
        // если значение из первого диапазона меньше значения из второго диапазона
        if (isLess(*beginB, *beginA)) {
            // добавляем текущее значение из второго диапазона
            *destination = *beginB; // пост-инкремент итератора может делать лишнее, а то и не существовать
            ++beginB;               // поэтому используем пред-инкремент
        } else {
            // иначе добавляем текущее значение из первого диапазона
            *destination = *beginA;
            ++beginA;
        }
    }
    // а в конце копируем всё оставшееся из второго диапазона и возвращаем указатель на конец нового диапазона
    return std::copy(beginB, endB, destination);
}
 
template<typename T>
class List {
public:
    using Iterator = ListIterator<T>;
    using ConstIterator = ListIterator<const T>;
 
    List() : base{} {}
 
    List(const List<T> &other): base{} {
        std::copy(other.begin(), other.end(), getBackInserter());
    }
 
    List<T> &operator=(const List<T> &other) {
        if (this != &other) {
            clear();
            std::copy(other.begin(), other.end(), getBackInserter());
        }
        return *this;
    }
 
    virtual ~List() {
        clear();
    }
 
    bool isEmpty() const {
        return &base == base.next;
    }
 
    void pushFront(const T &value) {
        new Node<T>(&base, value);
    }
 
    void clear() {
        while (!isEmpty()) {
            NodeBase *current = base.next;
            current->remove(&base);
            delete current;
        }
    }
 
    ConstIterator begin() const {
        return base.next;
    }
    ConstIterator end() const {
        // так не надо, так баги, вместо этого надо бы отдельный конст-итератор сделать
        return const_cast<NodeBase*>(&base);
    }
 
    Iterator begin() {
        return base.next;
    }
 
    Iterator end() {
        return &base;
    }
 
    BackInsertIterator<T> getBackInserter() {
        NodeBase *result;
        for (result = base.next; result != &base; result = result->next) {
        }
        return result;
    }
 
    // Этот метод должен принимать в качестве аргумента ссылку (или указатель) на
    // List (это список, который нужно объединить со списком этого объекта класса List, от которого был вызван метод)
    // и возвращать ссылку (или указатель) на объединенный список:
    List<T> mergeWith(const List<T> &other) const {
        List<T> result{};
        mergeSorted(begin(), end(), other.begin(), other.end(), result.getBackInserter(), std::less());
        return result;
    }
 
private:
    NodeBase base;
};
 
 
 
 
int main() {
 
    List<int> first;
    List<int> second;
 
    for (int i = 6; i >= 0; ----i) {
        first.pushFront(i);
    }
    for (int i = 15; i >= 0; ------i) {
        second.pushFront(i);
    }
 
    for (auto x : first) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
    for (auto x : second) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
 
    List<int> third = first.mergeWith(second);
 
    for (auto x : third) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
 
    return 0;
}
0
429 / 312 / 129
Регистрация: 09.02.2021
Сообщений: 1,096
Записей в блоге: 1
29.11.2021, 17:34  [ТС] 16
lemegeton, так можно без итераторов
0
4769 / 2579 / 892
Регистрация: 29.11.2010
Сообщений: 5,581
29.11.2021, 19:55 17
Цитата Сообщение от matviiv Посмотреть сообщение
lemegeton, так можно без итераторов
Да пожалуйста. Делайте без итераторов. Ктож вас заставляет.
Еще можно не на С++, можно без ввода, можно с двусвязными списками, можно со стандартными либами...
Вариантов почти бесконечно много.

Добавлено через 4 минуты
Мой пост был о том, что с итераторами многие штуки, которые нуждаются в проходе по списку, становятся проще.
И даже можно в стандартные алгоритмы.
0
29.11.2021, 19:55
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
29.11.2021, 19:55
Помогаю со студенческими работами здесь

Сумма полиномов(односвязных списков)
#include &lt;iostream&gt; #include &lt;fstream&gt; #include &lt;cmath&gt; using namespace std; struct...

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

Сортировка линейных(односвязных) списков
Всем доброго времени суток. Уже на протяжении нескольких дней бьюсь с сортировкой линейных списков....

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

Чем отличается сортировка односвязных списков от сортировки двусвязных?
Чем отличается сортировка односвязных списков от двусвязных списков? Если можете то на примере...

слияние списков
помогите с написание программы!!! нужно написать программу которая объединяет два упорядоченных...

Троичное слияние списков
Задание: даны три упорядоченных списка к примеру А В С, нужно слить их в едино(список Д). Помогите...


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

Или воспользуйтесь поиском по форуму:
17
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin
Copyright ©2000 - 2024, CyberForum.ru