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

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

Войти
Регистрация
Восстановить пароль
 
NewProject
2 / 2 / 0
Регистрация: 10.08.2012
Сообщений: 53
#1

Создание очереди и удаление элемента очереди по усмотрению пользователя - C++

27.05.2013, 09:00. Просмотров 1129. Ответов 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
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
#include <iostream>
#include <conio.h>
#include <windows.h>
#include <stdlib.h>
using namespace std;
 
// структура, описывающая один узел:
struct Node
{
    int data; // элемент данных
    Node *next, *prev; // указатели на следующий и предыдущий узел
};
 
// класс для работы с очередью:
class QueueInt
{
/* указатели на начало, конец очереди  и на текущий узел (указатель на текущий узел используется многими функциями, поэтому объявим его как элемент данных класса): */
    Node *front;
    Node *back;
    Node *token;
    int sum;
    int num;
// функции ввода-вывода:
    friend ostream& operator << (ostream&,QueueInt&);
    friend istream& operator >> (istream&, QueueInt&);
    public:
        QueueInt() {back = front = token = NULL;sum=0;} // конструктор по умолчанию
        QueueInt(int, int*); // основной конструктор
        QueueInt(const QueueInt&); // конструктор копирования
        ~QueueInt(); // деструктор
        bool Empty() { return front == NULL ? true: false;} // проверка, пустая ли очередь
        void Add(int val); //добавляет элемент в конец списка
        void del(int de);//удаление!!!!----==
        int Gettoken(); // текущий элемент данных
        int operator ~();
        int Arifm();//Среднеарифметическое
// операция, которая добавляет элемент в список в текущей позиции
};
// Определение функций:
// Основной конструктор
QueueInt :: QueueInt (int n, int* val)//инициализация
// параметрами являются количество элементов массива и указатель на массив
{
    back = front = token  = NULL;
    for (int i=0; i<n; i++)
        Add(val[i]); // добавляем элементы массива в очередь
}
// конструктор копирования:
QueueInt :: QueueInt(const QueueInt& list)
{
    back = front = token = NULL;
    Node* ptr = list.front;
 // указатель на текущий элемент копируемого объекта
    while  (ptr)
    {
        Add(ptr->data); 
// добавляем в очерель  элемент из копируемого списка
        ptr = ptr->next; 
// переходим к следующему элементу копируемого списка
    }
}
 
//  функция, которая добавляет элемент в конец очерели:
void QueueInt :: Add(int val)
{
    Node *p = new Node; // создаем новый узел
    p->data = val; // записываем элемент данных
    if(Empty()) // если очерель  еще пуста
    {
        front = back = p; 
// добавляемый элемент становится первым и последним
        p->next = p->prev = NULL; 
        //  предыдущего и последующего элементов нет
    }
    else
    {
        back->next = p;  // привязываем новый узел к последнему
        p->prev=back; p->next = NULL; // определяем значения указателей
        back=p; // новый узел становится последним
    }
}
/////1111111111111111111111111111111111111111111111111111111111111111111111111111111
 
 
void QueueInt :: del(int val)
{
    Node *p = new Node;// создаем новый узел
    token=front;
    
    if(Empty()) // если очерель еще пуста
    {
 
        cout<<"Очередь пуста!";
    }
    else
    {
        
        if (val>num)
        {
            cout<<"Не существует этотго элемента!";
        }else 
 
            for(int qw=1;qw<val;qw++)
            {
                token=token->next;
            }
        p=token->prev;
            if(p!=NULL)
            {
                p->next=token->next;
                
            }
            p=token->next;  
                if(p!=NULL)
                {
                    p->prev=token->prev;
                }
                p=token;
                if(p!=front || p!=back)//lдоп!!
                {                               
                delete p;
                num--;
                }else
                    if(p=front) 
                    {
                        cout<<"!!!!!!!!!";
                    }
    }
}
///////////////////------------------------------------------------------------------------------------------
int  QueueInt::Arifm()
{
    token=front;
    do
    {
        sum+=token->data;
        token=token->next;
    }while(token!=back);
    sum+=back->data;
cout << "Среднеарифменическое очереди:"<<sum/num<<endl;
return sum/num;
}
///////////---------------------------------------------------------------------------------------------------
//функция ввода:
istream & operator >> (istream &is, QueueInt& q)
{
   q.~QueueInt(); // Удаляем ранее существовавшую очерередь
   int a; int k;
   cout<<"Сколько элементов будете вводить? ";
   is >> k;
   q.num=k;
   for(int i=0; i<k; i++)
   {
    cout << i+1 << ": "; is >> a;
    q.Add(a);
   }
   return is;
}
 
//функция, которая определяет значение текущего элемента
int QueueInt :: Gettoken()
{
    if (token == NULL) token = front;
    if (token)
    {
        int rv = token->data; //считываем значение из текущего узла
        token = token->next; //текущим становится следующий узел
        return rv;
    }
    else return 0;
}
 
// функция вывода:
ostream& operator << (ostream& os, QueueInt& q)
{
    os << "< ";
    q.token = q.front; // переходим в начало списка q
    while(q.token) // пока список не закончен
    {
        if (q.token != q.front)
            cout <<", ";
        os << q.Gettoken(); // выводим очередной элемент списка
    }
    return os << ">" << endl;
}
 
//деструктор:
QueueInt :: ~QueueInt()
//Удаляет элементы cписка с конца:
{
    while (back) // если очередь не пуста
    {
        token = back; // берем последний узел
        back = back->prev; // предпоследний узел делаем последним
        delete token; // удаляем узел
        if (token==front) break; 
// если удалили первый узел, то останавливаем цикл
   }
}
 
 
 
int  QueueInt::operator ~()///среднее близское значение
{
    token=front;
    double sa2=Arifm();//среднеарифметическое 
    double sa=abs(token->data-sa2);
    double t,z=token->data;
    token=front;
    while(token!=back)
    {
        t=abs(token->data-sa2);
        if(sa>t)
        {
            sa=t;
            z=token->data;
        }
        token=token->next;
    }
return z;
}
 
 
 
//=========================================================
int main()
{
    setlocale(0,"");
    do
    {
        QueueInt list;
        cin >> list;
        cout << list;
        int data, n;
        cout << "Какой элемент удалить? ";
        cin >> n;
        {
            list.del(n); // удаляем n-ый элемент на data
            cout << list;
        }
        cout << "Самый близский элемент к среднему значению очереди: "<<~list<<endl;
                
    } while (_getch() != 27);
    return 0;
}
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
27.05.2013, 09:00     Создание очереди и удаление элемента очереди по усмотрению пользователя
Посмотрите здесь:

Удаление элемента из очереди - C++
Здравствуйте, проблема с очередями, совсем их не понимаю, перечитал много статей все равно не доходит.( Задание: Удалить каждый второй...

Удаление элемента из очереди по срабатыванию условия - C++
таким путем добавляю новую запись в очередь: void Add(Queue *Q, char kolname, int kolperiod, int kolvrem9) //добавление элемента { ...

Извлечь из очереди начальные элементы и вывести их значения и новые адреса начала и конца очереди - C++
Дано число N (&gt; 0) и указатели P1 и P2 на начало и конец непустой очереди. Извлечь из очереди N начальных элементов и вывести их значения...

Очереди. Дан массив. Создать две очереди, первая должна содержать все нечетные, а вторая - все четные - C++
Очереди. Дан массив. Создать две очереди, первая должна содержать все нечетные, а вторая - все четные числа из исходного набора; порядок...

Удаление из очереди чисел, кратных пяти - C++
Создать очередь из целых чисел. Вывести исходную очередь. Удалить из этой очереди числа кратные пяти. Вывести полученную очередь...

Удаление звеньев созданный по принципу очереди с++ - C++
Программа должна должна удалять звенья в которых Elem нечётный, где ошибка? Просто не работает и не погу понять почему ...

Создание Очереди - C++
Приветствую,помогите создать Прогу в Делфи или С++ Разработать программу,позваляющую формировать динамическую структуру данных Очередь....

Создать функцию удаления элемента очереди - C++
Ребят, столкнулся с такой задачей Дана простая очередь. Элемент очереди содержит следующую информацию: фамилия студента, шифр группы....

Создание класса очереди - C++
Создать класс, реализующую очередь целых чисел типа FIFO. Данные класса: массив очереди, указатели на начало очереди и на конец очереди....

Функция: вставка в начало очереди нового элемента - C++
Написать Функцию, которая вставляет в начало очереди новый элемент.


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

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Miwa123
27.05.2013, 10:59
  #2

Не по теме:

думаю фрилансеры за небольшое вознаграждение возьмутся

NewProject
2 / 2 / 0
Регистрация: 10.08.2012
Сообщений: 53
27.05.2013, 17:46  [ТС]     Создание очереди и удаление элемента очереди по усмотрению пользователя #3
все разобрался сам, вот код если кому то нужен
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
#include <iostream>
#include <conio.h>
#include <windows.h>
#include <stdlib.h>
#include <math.h>
using namespace std;
 
// структура, описывающая один узел:
struct Node
{
    int data; // элемент данных
    Node *next, *prev; // указатели на следующий и предыдущий узел
};
 
// класс для работы с очередью:
class QueueInt
{
/* указатели на начало, конец очереди  и на текущий узел (указатель на текущий узел используется многими функциями, поэтому объявим его как элемент данных класса): */
    Node *front;
    Node *back;
    Node *token;
    int sum;
    
// функции ввода-вывода:
    friend ostream& operator << (ostream&,QueueInt&);
    friend istream& operator >> (istream&, QueueInt&);
    public:
        int num;
        QueueInt() {back = front = token = NULL;sum=0;} // конструктор по умолчанию
        QueueInt(int, int*); // основной конструктор
        QueueInt(const QueueInt&); // конструктор копирования
        ~QueueInt(); // деструктор
        bool Empty() { return front == NULL ? true: false;} // проверка, пустая ли очередь
        void Add(int val); //добавляет элемент в конец очереди
        void del(int de);//удаление
        int Gettoken(); // текущий элемент данных
        void operator ~();//Близский элем по значению к арифм
        int Arifm();//Среднеарифметическое
};
 
//========================================================
// Основной конструктор
QueueInt :: QueueInt (int n, int* val)//инициализация
int a[]={1, -2, 3, -4, 5};
// параметрами являются количество элементов массива и указатель на массив
{
    back = front = token  = NULL;
    for (int i=0; i<n; i++)
        Add(int a[]+val[i]); // добавляем элементы массива в очередь
}
//========================================================
// конструктор копирования:
QueueInt :: QueueInt(const QueueInt& list)
{
    back = front = token = NULL;
    Node* ptr = list.front;
 // указатель на текущий элемент копируемого объекта
    while  (ptr)
    {
        Add(ptr->data); 
// добавляем в очерель  элемент из копируемого списка
        ptr = ptr->next; 
// переходим к следующему элементу копируемого списка
    }
}
//========================================================
//  функция, которая добавляет элемент в конец очереди:
void QueueInt :: Add(int val)
{
    Node *p = new Node; // создаем новый узел
    p->data = val; // записываем элемент данных
    if(Empty()) // если очерель  еще пуста
    {
        front = back = p; 
// добавляемый элемент становится первым и последним
        p->next = p->prev = NULL; 
        //  предыдущего и последующего элементов нет
    }
    else
    {
        back->next = p;  // привязываем новый узел к последнему
        p->prev=back; p->next = NULL; // определяем значения указателей
        back=p; // новый узел становится последним
    }
}
//========================================================
void QueueInt :: del(int val)
{
    Node *p = new Node;// создаем новый узел
    token=front;
    if(Empty()) // если очерель еще пуста
    {
        cout<<"Очередь пуста!";
    }else
        {
            if (val>num)
            {
            cout<<"Не существует этотго элемента!";
            }else 
                for(int qw=1;qw<val;qw++)
                {
                    token=token->next;
                }
        if(back==front)
            {
                num=0;
                front=NULL;
                
        }else {
 
            if(token==back)
                {
                    p=token;
                    back=token->prev;
                    token=back;
                    back->next=NULL;
                }else if (token==front)
                        {
                            p=token;
                            front=token->next;
                            token=front;
                        }else 
                            {
                                p=token->prev;
                                p->next=token->next;
                                token->prev=p;
                                p=token;        
                            }
                                                    
    delete p;
    num--;
                        }
        }
}
//========================================================
int  QueueInt::Arifm()
{
    if(num!=0)
    {
    token=front;
    do
    {
        sum+=token->data;
        token=token->next;
    }while(token!=back);
    sum+=back->data;
    cout << "Среднеарифменическое очереди:"<<sum/num<<endl;
    return sum/num;
    }else return 0;
}
//========================================================
//функция ввода:
istream & operator >> (istream &is, QueueInt& q)
{
   q.~QueueInt(); // Удаляем ранее существовавшую очерередь
   int a; int k;
   cout<<"Сколько элементов будете вводить? ";
   is >> k;
   q.num=k;
   for(int i=0; i<k; i++)
   {
    cout << i+1 << ": "; is >> a;
    q.Add(a);
   }
    return is;
}
 
//========================================================
int QueueInt :: Gettoken()//функция, которая определяет значение текущего элемента
{
    if (token == NULL) token = front;
    if (token)
    {
        int rv = token->data; //считываем значение из текущего узла
        token = token->next; //текущим становится следующий узел
        return rv;
    }
    else return 0;
}
 
//========================================================
ostream& operator << (ostream& os, QueueInt& q)// функция вывода
{
    if(q.num!=0)
    {
    os << "< ";
    q.token = q.front; // переходим в начало очереди q
    while(q.token) // пока очередь не закончен
    {
        if (q.token != q.front)
            cout <<", ";
        os << q.Gettoken(); // выводим очередной элемент очереди
    }
    return os << ">" << endl;
    }else 
   return os<<"Очередь пуста!"<<endl;
}
//========================================================
QueueInt :: ~QueueInt()//деструктор
//Удаляет элементы cписка с конца:
{
    
 
    while (back) // если очередь не пуста
    {
        token = back; // берем последний узел
        back = back->prev; // предпоследний узел делаем последним
        delete token; // удаляем узел
        if (token==front) break; 
// если удалили первый узел, то останавливаем цикл
    }
    
}
 
//========================================================
void  QueueInt::operator ~()///среднее близское значение
{
    if(num!=0)
    {
    token=front;
    double sa2=Arifm();//среднеарифметическое 
    double sa=abs(token->data-sa2);
    double t,z=token->data;
    token=front;
    while(token!=back)
    {
        t=abs(token->data-sa2);
        if(sa>t)
        {
            sa=t;
            z=token->data;
        }
        token=token->next;
    }
    cout<<"Наиболее близский по значению элемент имеет значение:"<<z<<endl;
    }
}
 
//========================================================
int main()
{
    int  n;
    setlocale(0,"");
    do
    {
        //int a[]={1, -2, 3, -4, 5};
        QueueInt lista(5, a);
        cout<<"Пример использования основного конструктора:";
        cout << lista;
 
        QueueInt list;
        cin >> list;
        cout << list;
        cout<<"Какой элемент удалить:";
        cin>>n;
        list.del(n);
        cout<<"Получившаяся очередь:"<<list;
        ~list;
    
            
    } while (_getch() != 27);
    return 0;
}
Ответ Создать тему
Опции темы

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