3 / 3 / 0
Регистрация: 02.03.2020
Сообщений: 15
1

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

03.03.2020, 00:06. Показов 3771. Ответов 10

Author24 — интернет-сервис помощи студентам
Можете пожалуйста помочь в решении проблемы не. Не могу создать функцию которая будет с созданного заранее списка заносить в новый элементы которые больше заданного значения. Я начинающий в данной теме.

Предоставляю код :
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
#include "SimpleNode.h"
 
 
using namespace std;
 
class SimpleNode
{
    
public:
    node* head;
    int value;
 
    SimpleNode() {
        node* head = 0;
    }
    //Формирование списка
    void formToList() {
        cout << "Введите елемент >";
        cin >> value;
        node* pv = new node;
        pv->value = value;
        pv->next = head;
        head = pv;
        
    }
 
    void endToList() {
        cout << "Введите елемент >";
        cin >> value;
        node* pv = new node;
        pv->value = value;
        pv->next = head;
        head = pv;
    }
 
 
    void upToList() {
        int num;
        cout << "Введите елемент >";
        cin >> num;
        node* pv = head;
        int i = 1;
        while (pv->next != nullptr) {
            pv = pv->next;
            i++;
        }
        node* temp = new node;
        pv->next = temp;
        pv = pv->next;
        pv->value = num;
        pv->next = 0;
    }
 
    void addElem()
    {
        node* pv = head;
        int number;
        cout << "intup number: ";
        cin >> number;
        int value;
        cout << "intup value: ";
        cin >> value;
 
        while (pv) {
            if (number == pv->value) {
                node* temp, * p;
                temp = new node;
                p = pv->next; // сохранение указателя на следующий узел
                pv->next = temp; // предыдущий узел указывает на создаваемый
                temp->value = value; // сохранение поля данных добавляемого узла
                temp->next = p; // созданный узел указывает на следующий элемент
                break;
            }
            else {
                pv = pv->next;
            }
        }
    }
 
 
    void deletList()
    {
        int a;
        cout << "Введите елемент котрый нужно удалить >";
        cin >> a;
        node* pv = new node;
        node* pd = new node;
        pv = head;
        while (pv) {
            if (pv->value == a) {
                node* pd = head;
                head = head->next;
                pv = head;
                delete pd;
            }
            else {
                if (pv->next != nullptr) {
                    if (pv->next->value == a) {
                        pd = pv;
                        pv = pv->next;
                        pd->next = pv->next;
                        delete pv;
                        pv = pd;
                    }
                    else {
                        pv = pv->next;
                    }
                }
                else {
                    pv = pv->next;
                }
            }
        }
    }
 
    void printList()
    {
        node* pv = head;
        if (!pv)
            std::cout << "List is nil\n";
        else
            while (pv)
            {
                cout << "=" << pv->value << std::endl;
                pv = pv->next;
            }
    }
 
    void positionList()
    {
        cout << "Введите елемент >";
        cin >> value;
        int i = 1;
        node* pv = new node;
        pv = head;
 
 
        while (pv->next != nullptr) {
            i++;
            pv = pv->next;
        }
 
        pv = head;
 
        while (pv) {
            if (pv->value == value) {
                cout << "Елемент \"" << value << "\" находится на позиции " << i << endl;
                i--;
                pv = pv->next;
            }
            else {
                i--;
                pv = pv->next;
            }
        }
    }
 
    node* number9(int value) {
        node* pv = new node;
        node* verh = new node;
        node* pd = new node;
        pv = head;
 
        if (!pv) {
            return verh;
        }
        while (pv) {
            if (pv->value > value) {
                pd->value = pv->value;
                pd->next = verh->next;
                verh = pd;
                verh->next = pd;
            }
            pv = pv->next;
        }
 
        return verh;
    }
 
    void printNumber9(node* head) {
        node* pv = new node; 
        pv= head;
        if (!pv)
            std::cout << "List is nil\n";
        else {
            while (pv)
            {
                cout << "=" << pv->value << std::endl;
                pv = pv->next;
            }
        }      
    }
};
Добавлено через 3 минуты
Предварительная функция number9 не работает.
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
03.03.2020, 00:06
Ответы с готовыми решениями:

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

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

Переписать в новый список элементы, которые больше среднеарифметического значения
Необходимо в составе программы описать функцию, которая формирует новый список &quot;L&quot;, включая в него...

Удалить те элементы исходного массива, которые больше заданного k
Задан массив целых чисел и целое число k . Удалить те элементы исходного массива , которые больше k.

10
1272 / 1029 / 470
Регистрация: 25.12.2016
Сообщений: 3,333
03.03.2020, 09:29 2
В функции number9:
Цитата Сообщение от Slava210200 Посмотреть сообщение
node* pv = new node;
node* verh = new node;
node* pd = new node;
pv = head;
Зачем нужно выделять память в первой строке, если в четвёртой строке значение указателя будет изменено, а выделенная память окажется недоступной? Тот же вопрос относится к функции deleteList.

Ещё из вашего кода непонятно что такое node. Где определение этого типа?
0
6579 / 4564 / 1843
Регистрация: 07.05.2019
Сообщений: 13,726
03.03.2020, 09:40 3
Цитата Сообщение от Slava210200 Посмотреть сообщение
Можете пожалуйста помочь в решении проблемы не. Не могу создать функцию которая будет с созданного заранее списка заносить в новый элементы которые больше заданного значения. Я начинающий в данной теме.
Для начала тебе надо разделить list и node, т.е. список и "элемент списка"
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct SimpleNode
{
    node *next;
    int value;
};
 
class SingleLinkedList
{
public:
 
    void addElem(int val);
 
....................................................
 
protected:
    SimpleNode *m_head = nullptr;
};
0
Just Do It!
3973 / 2308 / 636
Регистрация: 23.09.2014
Сообщений: 7,175
Записей в блоге: 3
03.03.2020, 10:27 4
Лучший ответ Сообщение было отмечено Slava210200 как решение

Решение

Slava210200,
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
///----------------------------------------------------------------------------|
/// Функция, 
///     которая будет с созданного заранее списка 
///     заносить в новый элементы которые больше заданного значения:
///     void foo(List& s, List& d, const int measure);
///----------------------------------------------------------------------------:
#include <iostream>
using namespace std;
 
///----------------------------------------------------------------------------|
/// class List.
///----------------------------------------------------------------------------:
struct Node
{   Node() : ptr(NULL) {}
    int   field;
    Node* ptr;
};
 
class List
{       Node *head;         // Корень списка.
        int count = 0;      // Количество узлов списка.
        Node* Prev(Node*);  // Переход к предыдущему узлу.
    public:
        List() : head(NULL){}
        
        int size()
        {   return count;        // Получение количества узлов списка
        }
        bool isEmpty()
        {   return head == NULL; // Проверка, пуст ли список
        }
        int getValue(Node* p)
        {   return p->field;     // Получение значения узла списка
        }
        void setValue(Node *p, int val)
        {   p->field = val;         // Установка значения узла списка.
        }
        Node* getFirst()
        {   return head;            // Получение корневого узла списка.
        }
        Node* getLast()           ; // Получение последнего узла списка.
        void  Clear  ()           ; // Очистка списка.
        Node* Next   (Node *)     ; // Переход к следующему узлу
        Node* Add    (int, Node*) ; // Добавление узла списка.
        Node* Delete (Node*)      ; // Удаление узла списка.
        void  Print  ()           ; // Вывод значений узлов списка.
        void  Swap  (Node*, Node*); // Взаимообмен двух узлов.
};
 
///----------------------------------------------------------------------------|
/// Реализация.
///----------------------------------------------------------------------------:
Node* List::Add(int num, Node* node = NULL)
{   Node *elem = new Node();
    elem->field = num;
    count++;
    if (node == NULL) // Добавление нового корня
    {   if (head == NULL)
        {   elem->ptr = NULL;
            head = elem;
        }
        else
        {   elem->ptr = head;
            head = elem;
        }
        return elem;
    }
    elem->ptr = node->ptr; // Добавление узла после текущего
    node->ptr = elem;
    return elem;
}
 
Node* List::Delete(Node* node)
{   if (node == NULL)
    {   return NULL;    // В списке нет узлов
    }
    count--;
    if (node == head)  // Удаление корневого узла
    {   head = node->ptr;
        delete node;
        return head;
    }
    Node* prev = Prev(node); // Удаление промежуточного узла
    prev->ptr = node->ptr;
    delete node;
    return prev;
}
 
Node* List::Next(Node* node)
{   if (isEmpty()) return NULL;
    return node->ptr;
}
 
Node* List::Prev(Node* node)
{   if (isEmpty()) return NULL;
    if (node == head) return NULL;
    Node *p = head;
    while (p->ptr != node)
        p = p->ptr;
    return p;
}
 
Node* List::getLast()
{   Node* p = head;
    while (Next(p) != NULL)
        p = Next(p);
    return p;
}
 
void List::Clear()
{   class Node *p = head;
    if (p == NULL) return;
    do
    {   Node *d = p;
        p = Next(p);
        delete d;
    }
    while (p != NULL);
    count = 0;
    head = NULL;
}
 
void List::Print()
{   if (isEmpty())
    {   cout << "Список пуст" << endl;
        return;
    }
    Node *p = head;
    do
    {   cout << getValue(p) << " ";
        p = Next(p);
    }
    while (p != NULL);
    cout << endl;
}
 
void List::Swap(Node* node1, Node* node2)
{   if (node1 == NULL
            || node2 == NULL) return; // не допускаем обмен с несуществующим узлом
    if (node1 == node2)
        return; // если один узел указан дважды, менять ничего не надо
    if (node2->ptr == node1) // если node2 находится перед node1, меняем их местами
    {   Node *p = node1;
        node1 = node2;
        node2 = p;
    }
    Node *prev1 = Prev(node1);
    Node *prev2 = Prev(node2);
    Node *next1 = Next(node1);
    Node *next2 = Next(node2);
    if (next1 == node2) // обмен соседних узлов
    {   if (prev1 != NULL)
            prev1->ptr = node2;
        else
            head = node2;
        node2->ptr = node1;
        node1->ptr = next2;
        return;
    }
    if (prev1 != NULL)  // обмен отстоящих узлов
        prev1->ptr = node2;
    else
        head = node2;
    if (prev2 != NULL)
        prev2->ptr = node1;
    else
        head = node1;
    node2->ptr = next1;
    node1->ptr = next2;
}
 
///----------------------------------------------------------------------------|
/// Функция, которая будет с созданного заранее списка 
/// заносить в новый элементы которые больше заданного значения.
///----------------------------------------------------------------------------:
void foo(List& s, List& d, const int measure)
{   ///-----------------------------------------------|
    /// В d помещаем элементы, которые больше measure.|
    ///-----------------------------------------------:
    for(Node* p = s.getFirst(); p; p = s.Next(p))
    {   if(p->field > measure)
        {   d.Add(p->field);
        }
    }
}
 
///----------------------------------------------------------------------------|
/// Тестовый пример.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    cout << "Создаем список\n";
    List list;
    list.Print();
    
    const int N = 10;
    cout << "\nПомещаем " << N << " элементов в начало:\n";
    for (int i = 0; i < N; i++)
    {   int z;
        cout << ">> "; cin >> z;
        list.Add(z);
    }
    list.Print();
    
    int n; cout << "\nВведите критерий: "; cin >> n;
    
    cout << "\nСоздаем список Dest\n";
    List Dest;
    
    ///---------------|
    /// Тест.         |
    ///---------------:
    foo(list, Dest, n);
    
    cout << "\nРезультат в D:\nэлементы больше критерия " << n << ":\n";
    Dest.Print();
    
    cin.get();
    cin.get();
    return 0;
}
1
3 / 3 / 0
Регистрация: 02.03.2020
Сообщений: 15
03.03.2020, 21:08  [ТС] 5
Спасибо огромное)
Очень благодарен.
Кстати, еще можешь пожалуйста подсказать как переделать под данный класс под функцию поиска номера элемента в списке?
0
Just Do It!
3973 / 2308 / 636
Регистрация: 23.09.2014
Сообщений: 7,175
Записей в блоге: 3
03.03.2020, 21:34 6
Лучший ответ Сообщение было отмечено Slava210200 как решение

Решение

Цитата Сообщение от Slava210200 Посмотреть сообщение
Кстати, еще можешь пожалуйста подсказать как переделать под данный класс под функцию поиска номера элемента в списке?
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
///----------------------------------------------------------------------------|
/// Функция,
///     которая будет с созданного заранее списка:
///     заносить в новый элементы которые больше заданного значения:
///     void foo(List& s, List& d, const int measure);
///
/// Функция,
///     поиска номера элемента в списке:
///     int foo(List& s, const int measure);
///
///    аналог(дубликат) добавлен в класс.
///----------------------------------------------------------------------------:
#include <iostream>
using namespace std;
 
///----------------------------------------------------------------------------|
/// class List.
///----------------------------------------------------------------------------:
struct Node
{   Node() : ptr(NULL) {}
    int   field;
    Node* ptr;
};
 
class List
{       Node *head;         // Корень списка.
        int count = 0;      // Количество узлов списка.
        Node* Prev(Node*);  // Переход к предыдущему узлу.
    public:
        List() : head(NULL) {}
 
        int size()
        {   return count;        // Получение количества узлов списка
        }
        bool isEmpty()
        {   return head == NULL; // Проверка, пуст ли список
        }
        int getValue(Node* p)
        {   return p->field;     // Получение значения узла списка
        }
        void setValue(Node *p, int val)
        {   p->field = val;         // Установка значения узла списка.
        }
        Node* getFirst()
        {   return head;            // Получение корневого узла списка.
        }
        Node* getLast()           ; // Получение последнего узла списка.
        void  Clear  ()           ; // Очистка списка.
        Node* Next   (Node *)     ; // Переход к следующему узлу
        Node* Add    (int, Node*) ; // Добавление узла списка.
        Node* Delete (Node*)      ; // Удаление узла списка.
        void  Print  ()           ; // Вывод значений узлов списка.
        void  Swap  (Node*, Node*); // Взаимообмен двух узлов.
 
        ///--------------------------------------------------------------------|
        /// Функция поиска номера элемента в списке.
        ///--------------------------------------------------------------------:
        int foo(const int measure)
        {   if(measure >= count)
                std::cout << "ERROR: Номер поиска вне диапазона.\n";
            else
            {   int i = 0;
                for(Node* p = head; p; p = this->Next(p), i++)
                {   if(i == measure)
                    {   return p->field;
                    }
                }
            }
            return 0;
        }
};
 
///----------------------------------------------------------------------------|
/// Реализация.
///----------------------------------------------------------------------------:
Node* List::Add(int num, Node* node = NULL)
{   Node *elem = new Node();
    elem->field = num;
    count++;
    if (node == NULL) // Добавление нового корня
    {   if (head == NULL)
        {   elem->ptr = NULL;
            head = elem;
        }
        else
        {   elem->ptr = head;
            head = elem;
        }
        return elem;
    }
    elem->ptr = node->ptr; // Добавление узла после текущего
    node->ptr = elem;
    return elem;
}
 
Node* List::Delete(Node* node)
{   if (node == NULL)
    {   return NULL;    // В списке нет узлов
    }
    count--;
    if (node == head)  // Удаление корневого узла
    {   head = node->ptr;
        delete node;
        return head;
    }
    Node* prev = Prev(node); // Удаление промежуточного узла
    prev->ptr = node->ptr;
    delete node;
    return prev;
}
 
Node* List::Next(Node* node)
{   if (isEmpty()) return NULL;
    return node->ptr;
}
 
Node* List::Prev(Node* node)
{   if (isEmpty()) return NULL;
    if (node == head) return NULL;
    Node *p = head;
    while (p->ptr != node)
        p = p->ptr;
    return p;
}
 
Node* List::getLast()
{   Node* p = head;
    while (Next(p) != NULL)
        p = Next(p);
    return p;
}
 
void List::Clear()
{   class Node *p = head;
    if (p == NULL) return;
    do
    {   Node *d = p;
        p = Next(p);
        delete d;
    }
    while (p != NULL);
    count = 0;
    head = NULL;
}
 
void List::Print()
{   if (isEmpty())
    {   cout << "Список пуст" << endl;
        return;
    }
    Node *p = head;
    do
    {   cout << getValue(p) << " ";
        p = Next(p);
    }
    while (p != NULL);
    cout << endl;
}
 
void List::Swap(Node* node1, Node* node2)
{   if (node1 == NULL
            || node2 == NULL) return; // не допускаем обмен с несуществующим узлом
    if (node1 == node2)
        return; // если один узел указан дважды, менять ничего не надо
    if (node2->ptr == node1) // если node2 находится перед node1, меняем их местами
    {   Node *p = node1;
        node1 = node2;
        node2 = p;
    }
    Node *prev1 = Prev(node1);
    Node *prev2 = Prev(node2);
    Node *next1 = Next(node1);
    Node *next2 = Next(node2);
    if (next1 == node2) // обмен соседних узлов
    {   if (prev1 != NULL)
            prev1->ptr = node2;
        else
            head = node2;
        node2->ptr = node1;
        node1->ptr = next2;
        return;
    }
    if (prev1 != NULL)  // обмен отстоящих узлов
        prev1->ptr = node2;
    else
        head = node2;
    if (prev2 != NULL)
        prev2->ptr = node1;
    else
        head = node1;
    node2->ptr = next1;
    node1->ptr = next2;
}
 
///----------------------------------------------------------------------------|
/// Функция, которая будет с созданного заранее списка
/// заносить в новый элементы которые больше заданного значения.
///----------------------------------------------------------------------------:
void foo(List& s, List& d, const int measure)
{   ///-----------------------------------------------|
    /// В d помещаем элементы, которые больше measure.|
    ///-----------------------------------------------:
    for(Node* p = s.getFirst(); p; p = s.Next(p))
    {   if(p->field > measure)
        {   d.Add(p->field);
        }
    }
}
 
///----------------------------------------------------------------------------|
/// Функция поиска номера элемента в списке.
///----------------------------------------------------------------------------:
int foo(List& s, const int measure)
{   if(measure >= s.size())
        std::cout << "ERROR: Номер поиска вне диапазона.\n";
    else
    {   int i = 0;
        for(Node* p = s.getFirst(); p; p = s.Next(p), i++)
        {   if(i == measure)
            {   return p->field;
            }
        }
    }
    return 0;
}
 
///----------------------------------------------------------------------------|
/// Тестовый пример.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    cout << "Создаем список\n";
    List list;
    list.Print();
 
    const int N = 10;
    cout << "\nПомещаем " << N << " элементов в начало:\n";
    for (int i = 0; i < N; i++)
    {   int z;
        cout << ">> ";
        cin >> z;
        list.Add(z);
    }
    list.Print();
 
    std::cout << "Значение третьего элемента(нумераци с нуля!): "
              << foo(list, 3) << "\n";
              
    std::cout << "Значение 5 элемента(нумераци с нуля!): "
              << list.foo(5) << "\n";
 
    int n;
    cout << "\nВведите критерий: ";
    cin >> n;
 
    cout << "\nСоздаем список Dest\n";
    List Dest;
 
    ///---------------|
    /// Тест.         |
    ///---------------:
    foo(list, Dest, n);
 
    cout << "\nРезультат в D:\nэлементы больше критерия " << n << ":\n";
    Dest.Print();
 
    cin.get();
    cin.get();
    return 0;
}
1
3 / 3 / 0
Регистрация: 02.03.2020
Сообщений: 15
03.03.2020, 22:23  [ТС] 7
Прости последний вопрос по данной теме. Каким образом с двусвязного списка занести элементы в односвязный.
Спасибо тебе еще раз огромное за помощь)
0
Just Do It!
3973 / 2308 / 636
Регистрация: 23.09.2014
Сообщений: 7,175
Записей в блоге: 3
03.03.2020, 22:32 8
Цитата Сообщение от Slava210200 Посмотреть сообщение
Каким образом с двусвязного списка занести элементы в односвязный.
Два шага:
1.
прочитать значение элемента вы можете?
читаете из.
2.
занести значение элемента вы можете?
заносите в.
1
3 / 3 / 0
Регистрация: 02.03.2020
Сообщений: 15
03.03.2020, 22:35  [ТС] 9
XLAT,
Просто по заданию нужно было создать еще один список в который нужно занести данные с двусвязного списка также.
Просто не получается корректно написать функцию переноса с двусвязного списка.
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
#pragma once
#include <iostream>
 
using namespace std;
 
struct dNode {
    int value;
    dNode* next;
    dNode* prev;
};
 
class DoubleNode
{
public:
    int position;
    int value;
    int pos;
    dNode* head = new dNode;
    DoubleNode() {
        head = 0;
    }
 
    dNode* getFirst()
    {
        return head;            // Получение корневого узла списка.
    }
    dNode* Next(dNode* node)
    {
        if (isEmpty()) return NULL;
        if(node)
            return node->next;
    }
    bool isEmpty()
    {
        return head == NULL; // Проверка, пуст ли список
    }
 
 
    void addEndList()
    {
        cout << "Значение > "; cin >> value;
        cout << "Позиция > "; cin >> position;
        dNode* node = new dNode; //создание нового элемента
        node->value = value; //присвоение элементу значения
        if (head == nullptr) //если список пуст
        {
            node->next = node; //установка указателя next
            node->prev = node; //установка указателя prev
            head = node; //определяется голова списка
        }
        else
        {
            dNode* p = head;
            for (int i = position; i > 1; i--) p = p->next;
            p->prev->next = node;
            node->prev = p->prev;
            node->next = p;
            p->prev = node;
        }
        cout << "\nЭлемент добавлен...\n\n";
    }
 
    void DeleteList()
    {
        cout << "Позиция > "; cin >> position;
        if (head == nullptr) { cout << "\nСписок пуст\n\n"; return; }
        if (head == head->next)
        {
            delete head;
            head = nullptr;
            cout << "\nЭлемент удален...\n\n";
        }
        else
        {
            dNode* a = head;
            for (int i = position; i > 1; i--) a = a->next;
            if (a == head) head = a->next;
            a->prev->next = a->next;
            a->next->prev = a->prev;
            delete a;
            cout << "\nЭлемент удален...\n\n";
        }
    }
 
    void PrintList()
    {
        if (head == NULL) cout << "\nСписок пуст\n\n";
        else
        {
            dNode* a = head;
            cout << "\nЭлементы списка: ";
            do
            {
                cout << a->value << " ";
                a = a->next;
            } while (a != head); cout << "\n\n";
        }
    }
 
    void positionEllement() {
 
        cout << "Елемент > "; cin >> value;
        if (head == NULL) cout << "\nСписок пуст\n\n";
 
        dNode* pv = head;
        int i = 1;
        bool ind = false;
 
        if (pv == head) {
            if (pv->value == value) {
                cout << "Елемент " << value << " находится на позиции 1" << "\n\n";
                pv = pv->next;
                i++;
                ind = true;
            }
            else {
                i++;
                pv = pv->next;
            }
        }
        while (pv != head) {
            if (pv->value == value) {
                cout << "\nЕлемент " << value << " находится на позиции " << i << "\n";
                pv = pv->next;
                i++;
                ind = true;
            }
            else {
                i++;
                pv = pv->next;
            }
        }
        if (!ind) {
            cout << "Даного елемнета нет в списке";
        }
    }
 
    void addUpList() {
        cout << "Елемент > "; cin >> value;
        dNode* pv = new dNode;
        dNode* pd = new dNode;
        pd = head->prev;
        pv->next = head;
        pv->prev = head->prev;
        pv->value = value;
        head->prev = pv;
        pd->next = pv;
        head = pv;
    }
 
    void addToList() {
        cout << "Елемент > "; cin >> value;
        cout << "После какого > "; cin >> pos;
        dNode* pv = head;
        dNode* pd = new dNode;
        dNode* pp = new dNode;
        if (pv == head) {
            if (pv->value == pos) {
                pp = head->next;
                pd->value = value;
                pd->next = head->next;
                pd->prev = head;
                head->next = pd;
                pp->prev = pd;
            }
            else {
                pv = pv->next;
            }
        }
 
        while (pv != head) {
            if (pv->value == pos) {
                pp = pv->next;
                pd->value = value;
                pd->next = pv->next;
                pd->prev = pv;
                pp->prev = pd;
                pv->next = pd;
                pv = pv->next;
            }
            else {
                pv = pv->next;
            }
        }
    }
 
    dNode* Add(int num, dNode* node = NULL)
    {
        dNode* elem = new dNode();
        elem->value = num;
        if (node == NULL) // Добавление нового корня
        {
            if (head == NULL)
            {
                elem->next = NULL;
                head = elem;
            }
            else
            {
                elem->next = head;
                head = elem;
            }
            return elem;
        }
        elem->next = node->next; // Добавление узла после текущего
        node->next = elem;
        return 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
#pragma once
 
///----------------------------------------------------------------------------|
/// Функция, которая будет с созданного заранее списка
/// заносить в новый элементы которые больше заданного значения.
///----------------------------------------------------------------------------:
void foo(List& s, List& d, const int measure)
{   ///-----------------------------------------------|
    /// В d помещаем элементы, которые больше measure.|
    ///-----------------------------------------------:
    for (Node* p = s.getFirst(); p; p = s.Next(p))
    {
        if (p->field > measure)
        {
            d.Add(p->field);
        }
    }
}
 
[COLOR="DarkRed"]void foo(DoubleNode& s, List& d, const int measure)
{   ///-----------------------------------------------|
    /// В d помещаем элементы, которые больше measure.|
    ///-----------------------------------------------:
    for (dNode* p = s.getFirst(); p; )
    {
        if (p->value > measure)
        {
            d.Add(p->value);
        }
        p = s.Next(p);
        if (p == s.getFirst()) {
            return;
        }
    }
}[/COLOR]
 
///----------------------------------------------------------------------------|
/// Функция поиска номера элемента в списке.
///----------------------------------------------------------------------------:
int foo(List& s, const int measure)
{
    if (measure >= s.size())
        std::cout << "ERROR: Номер поиска вне диапазона.\n";
    else
    {
        int i = 0;
        for (Node* p = s.getFirst(); p; p = s.Next(p), i++)
        {
            if (i == measure)
            {
                return p->field;
            }
        }
    }
    return 0;
}

и сама функция 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
#include <iostream>
#include <Windows.h>
#include <math.h>
#include <iomanip>
#include "SimpleConnected.h"
#include "DoubleConnected.h"
#include"func.h"
 
using namespace std;
 
int main()
{
    setlocale(LC_ALL, "Rus");
    int n;
    List list;
    List Dest;
    int N = 0;
    int x = 0;
    ///////////
    DoubleNode doubleN;
 
    do{
        system("cls");
        cout << "1. Робота с односвязным списком" << endl;
        cout << "2. Робота с двусвязным списком" << endl;
        cout << "3. Задание номер №5" << endl;
        cout << "4. Задание номер №9" << endl;
        cout << endl << "Позиция >" << endl;
        cin >> x;
        switch (x)
        {
        case 1:
            system("cls");
            do {
                cout << "1. Сформировать список" << endl;
                cout << "2. Добавить елемент в конец" << endl;
                cout << "3. Добавить елемент в начало" << endl;
                cout << "4. Добавить значение после елемента " << endl;
                cout << "5. Удалить елемент" << endl;
                cout << "6. Найти номер елемента" << endl;
                cout << "7. Вывести на екран" << endl;
                cout << "0. Вернутся назад" << endl;
                cout << endl << "Позиция >";
                cin >> n;
                switch (n)
                {
                case 1:
                    system("cls");
 
                    cout << "Введите еоличество елементов >";
                    cin >> N;
                    cout << "\nПомещаем " << N << " элементов в начало:\n";
                    for (int i = 0; i < N; i++)
                    {
                        int z;
                        cout << "Введите елемент > ";
                        cin >> z;
                        list.Add(z);
                    }
                    break;
                case 2:
                    system("cls");
                    int z;
                    cout << "Введите елемент >";
                    cin >> z;
                    list.Add(z);
                    break;
                case 3:
                    system("cls");
                    cout << "Введите елемент > ";
                    cin >> z;
                    list.Add(z);
                    break;
                case 4:
                    system("cls");
                    
                    break;
                case 5:
                    system("cls");
                    
                    break;
                case 6:
                    system("cls");
 
                    cout<< "Введите номер елемента > ";
                    cin >> z;
                    cout << "Елемент " << z << " находится на позиции " << foo(list, z) << endl;
                    break;
                case 7:
                    system("cls");
                    list.Print();
                    break;
                }
            } while (n!=0);
            system("cls");
            break;
        case 2:
            system("cls");
            do {
                cout << "1. Добавить елемент в конец" << endl;
                cout << "2. Добавить елемент в начало" << endl;
                cout << "3. Добавить значение после елемента " << endl;
                cout << "4. Удалить елемент" << endl;
                cout << "5. Найти номер елемента" << endl;
                cout << "6. Вывести на екран" << endl;
                cout << "0. Вернутся назад" << endl;
                cout << endl << "Позиция >";
                cin >> n;
                switch (n)
                {
                case 1:
                    system("cls");
                    doubleN.addEndList();
                    break;
                case 2:
                    system("cls");
                    doubleN.addUpList();
                    break;
                case 3:
                    system("cls");
                    doubleN.addToList();
                    break;
                case 4:
                    system("cls");
                    doubleN.DeleteList();
                    break;
                case 5:
                    system("cls");
                    doubleN.positionEllement();
                    break;
                case 6:
                    system("cls");
                    doubleN.PrintList();
                    break;
                }
            } while (n != 0);
            break;
        case 3:
            system("cls");
            do {
                cout << "1. Создать список" << endl;
                cout << "2. Вывести на екран" << endl;
                cout << "0. Вернутся назад" << endl;
                cout << endl << "Позиция >";
                cin >> n;
                switch (n)
                {
                case 1:
                    system("cls");
                    cout << "\nСоздаем список Dest\n";
 
                    foo(list, Dest, n);
                    foo(doubleN, Dest, n);
                    break;
                case 2:
                    system("cls");
                    cout << "\nРезультат в D:\nэлементы больше критерия " << n << ":\n";
                    Dest.Print();
                    break;
                }
            } while (n != 0);
            break;
        case 4:
            system("cls");
 
            break;
        }
    } while (x != 0);
}
0
Just Do It!
3973 / 2308 / 636
Регистрация: 23.09.2014
Сообщений: 7,175
Записей в блоге: 3
03.03.2020, 23:08 10
Лучший ответ Сообщение было отмечено Slava210200 как решение

Решение

Цитата Сообщение от Slava210200 Посмотреть сообщение
1.
вот первый шаг,
у вас есть фукции, которыми вы можете прочитать значение нода.
C++
23
24
25
26
27
28
29
30
31
32
dNode* getFirst()
 {
 return head; // Получение корневого узла списка.
 }
 dNode* Next(dNode* node)
 {
 if (isEmpty()) return NULL;
 if(node)
 return node->next;
 }

2.

далее в односвязном списке есть функция
C++
76
Node* List::Add(int num, Node* node = NULL)
которая может занести значения внутрь себя.

---

Прототип самой функции, которую вам надо написать:
C++
1
2
/// прототип:
void merge(DoubleNode& source, List& dest);
1
3 / 3 / 0
Регистрация: 02.03.2020
Сообщений: 15
03.03.2020, 23:10  [ТС] 11
Еще раз спасибо Вам огромное )
1
03.03.2020, 23:10
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
03.03.2020, 23:10
Помогаю со студенческими работами здесь

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

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

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

Построить новый список L3, включив в него элементы, которые входят одновременно в L1 и в L2
Даны два целочисленных списка L1 и L2. Построить новый список L3, включив в него элементы, которые...


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

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

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