Рекомендация: прочитайте задачу! Выполните ее и сравните полученный результат с картинкой CMD
Если вы полностью уверены что не можете осилить эту задачу, советую вам просмотреть код и полностью в нем разобраться! Протестировать все в отладчике!
Создайте шаблонную очередь на базе двунаправленного списка!
/*Athor Dombrovsky I.V.*
*Academy "STEP" *
*GROUP 32PPS21* *
***********************
TASK =======>>>>>>>>>>>>>>>>>
Реализовать шаблонный класс "Очередь" на основе двусвязного списка.
*/
#include <iostream>
using namespace std;
#define STOP system("pause");
#define COLOR_GREEN_TEXT system("color 0A");
template<class T>
class Node {
public:
Node * next;
Node * previous;
T data;
};
template<class T>
class List
{
public:
List();
~List();
void addElement(T data);
void showListStartHead();
void showListStartTail();
void deleteElementListFirst();
void deleteElementListLast();
void deleteAllListWithFirst();
void deleteAllListWithLast();
void DeleteSpecifiedElement(int position, int searchStart);
int getSize();
private:
Node<T> * head;
Node<T> * Tail;
int count;
};
template<class T>
List<T>::List() : head(NULL), Tail(NULL), count(0)
{
// DEFAULT
cout << "WORK CONSTRUCTOR" << endl;
}
template<class T>
List<T>::~List() // DESTRUCTOR
{
this->head = NULL;
this->Tail = NULL;
this->count = 0;
}
template<class T>
void List<T>::addElement(T data) // ADD ELEMENTS TO LIST
{
Node<T> * temp = new Node<T>;
if (head == NULL)
{
temp->previous = NULL;
temp->next = NULL;
temp->data = data;
head = temp;
Tail = temp;
count++;
}
else
{
temp->previous = Tail;
Tail->next = temp;
temp->next = NULL;
temp->data = data;
Tail = temp;
count++;
}
}
template<class T>
void List<T>::showListStartHead() // DISPLAY LIST WITH FIRST
{
Node<T> * temp = head;
while (temp != NULL)
{
cout << "Adress = " << temp << " " << temp->data << endl;
temp = temp->next;
}
}
template<class T>
void List<T>::showListStartTail() // DISPLAY LIST WITH LAST
{
Node<T> * temp = Tail;
while (temp != NULL)
{
cout << "Adress = " << temp << " " << temp->data << endl;
temp = temp->previous;
}
}
template<class T>
void List<T>::deleteElementListFirst() // DELETE ELEMENT WITH FIRST
{
if (count > 0)
{
Node<T> * temp = head;
if (temp->next != NULL)
{
head = temp->next;
head->previous = NULL;
delete temp;
count--;
}
else
{
delete temp;
count--;
head = Tail = NULL;
}
}
else
{
cerr << "List empty!" << endl;
}
}
template<class T>
void List<T>::deleteElementListLast() // DELETE ELEMENT WITH LAST
{
if (count > 0)
{
Node<T> * temp = Tail;
if (temp->previous != NULL)
{
Tail = temp->previous;
Tail->next = NULL;
delete temp;
count--;
}
else
{
delete temp;
count--;
head = Tail = NULL;
}
}
else
{
cerr << "List empty!" << endl;
}
}
template<class T>
void List<T>::deleteAllListWithFirst() // DELETE ALL LIST WITH FIRST
{
while (count)
{
deleteElementListFirst();
}
}
template<class T>
void List<T>::deleteAllListWithLast() // DELETE ALL LIST WITH LAST
{
while (count)
{
deleteElementListLast();
}
}
template<class T>
void List<T>::DeleteSpecifiedElement(int position, int searchStart) // SEARCHSTART 0 => FIRST OR SEARCHSTART 1 => LAST
{
if (count > 0)
{
Node<T> * temp = NULL;
bool flag = true;
if (searchStart >= 0 && searchStart <= 1)
{
if (position > 1 && position < count) // IF LIST HAS MORE ONE ELEMENT
{
if (searchStart == 0)
{
temp = head;
}
if (searchStart == 1)
{
temp = Tail;
}
while (position - 1)
{
if (searchStart == 0)
{
temp = temp->next;
}
if (searchStart == 1)
{
temp = temp->previous;
}
position--;
}
temp->previous->next = temp->next; // REMAP ADDRESS = NEXT ELEMENT
temp->next->previous = temp->previous; // REMAP ADDRESS = PRAVIOUS ELEMENT
delete temp;
count--;
}else if (position == 1 || position == count)
{
if (searchStart == 0)
{
if(position == 2)
deleteElementListLast();
else
deleteElementListFirst();
}
if (searchStart == 1)
{
if (position == 2)
deleteElementListFirst();
else
deleteElementListLast();
}
}
if (position < 0 || position > count)
{
cerr << "Position error!" << endl;
}
}
else
{
cerr << "First and last error!" << endl;
}
}
else
{
cerr << "List empty!" << endl;
}
}
template<class T>
int List<T>::getSize()
{
return count;
}
template<class T>
class Queue // FIFO
{
public:
Queue();
~Queue();
void addElement(T element);
int getSize();
void showQueue();
void deleteElement();
void clearQueue();
private:
List<T> l;
int SIZE;
};
template<class T>
Queue<T>::Queue() : SIZE(0) // CONSTRUCTOR
{
// DEFAULT
}
template<class T>
Queue<T>::~Queue() // DESTRUCTOR
{
this->SIZE = 0;
}
template<class T>
void Queue<T>::addElement(T element) // ADD ELEMENT TO QUEUE
{
l.addElement(element);
this->SIZE = l.getSize();
}
template<class T>
int Queue<T>::getSize() // GET SIZE QUEUE
{
return this->SIZE;
}
template<class T>
void Queue<T>::showQueue() // DISPLAY QUEUE
{
l.showListStartHead();
}
template<class T>
void Queue<T>::deleteElement() // DELETE ELEMENT OF QUEUE
{
l.deleteElementListFirst();
this->SIZE = l.getSize();
}
template<class T>
void Queue<T>::clearQueue()
{
l.deleteAllListWithFirst();
}
int main() {
COLOR_GREEN_TEXT
Queue<int> q; // CREATE QUEUE
q.addElement(52);
q.addElement(85);
q.addElement(100);
cout << "**********************************" << endl;
q.showQueue();
cout << "SIZE = " << q.getSize() << endl;
cout << "**********************************" << endl;
q.deleteElement();
q.showQueue();
cout << "SIZE = " << q.getSize() << endl;
cout << "**********************************" << endl;
q.deleteElement();
q.showQueue();
cout << "SIZE = " << q.getSize() << endl;
cout << "**********************************" << endl;
STOP
}
/*Dombrovsky I.V.
TASK
Есть строка символов, признаком конца, которой является «;». В строке могут
быть фигурные, круглые, квадратные скобки. Скобки могут быть
открывающими и закрывающими.
Необходимо проверить корректность расстановки скобок.
Правила расстановки скобок следующие:
1. Каждая открывающая скобка должна иметь справа такую же закрывающую.
2. Открывающие и закрывающие пары скобок разных типов должны быть
правильно расположены по отношению друг к другу.
■■Пример правильной строки: ({x-y-z}*[x+2y]-(z+4x));
■■Пример неправильной строки: ([x-y-z}*[x+2y)-{z+4x)].
Если все правила соблюдены выведите информационное сообщение о
корректности строки, иначе покажите строку до места возникновения первой
ошибки.
Подсказка. Данные действия можно запрограммировать на основе стека.
*/
#include <iostream>
#include <new>
#include <cstring>
using namespace std;
#define STOP_CMD system("pause");
#define COLOR_CMD system("color 0A");
class Stack // STACK
{
public:
Stack();
~Stack();
void clear();
void setElement(const char element);
char getElement();
int getSize();
int getCount();
void show();
private:
char * STACK;
const int SIZE = 80;
int count;
};
Stack::Stack() : STACK(NULL), count(0) // CONSTRUCTOR
{
try { // CHECK MEMORY
STACK = new char[SIZE + 1]();
}
catch (bad_alloc &memoryAllocationException) {
cerr << "Exception occured: [ERROR MEMORY]" << memoryAllocationException.what() << endl; // Fixed output
}
}
Stack::~Stack() // DESTRUCTOR
{
delete[] this->STACK;
this->STACK = NULL;
count = 0;
}
void Stack::clear() // CLEAR STACK
{
if (count > 0)
{
while (count)
{
getElement();
}
}
}
void Stack::setElement(const char element) // // ADD ELEMENT TO STACK
{
if (count < SIZE)
{
this->STACK[count] = element;
count++;
}
}
char Stack::getElement() // GET ELEMENT OF STACK
{
if (count > 0)
{
char temp = STACK[count - 1];
this->STACK[count] = 0;
count--;
return temp;
}
else
{
return 0;
}
}
int Stack::getSize() // GET SIZE ==>> STACK
{
return this->SIZE;
}
int Stack::getCount() // GET VALUE BUSY STACK NOW
{
return this->count;
}
void Stack::show() // DISPLAY STACK TO CMD
{
for (size_t i = 0; i < count; i++)
{
cout << this->STACK[i];
}
cout << endl;
}
int main(){
COLOR_CMD // CONST CMD COLOR TEXT GREEN BACKGROUND BLACK
//----------------------------------------------------
Stack stack; // CREATE STACK
//----------------------------------------------------
cout << "Enter line without space MAX [80]: " << endl;
cout << "Exeample: ({x-y-z}*[x+2y]-(z+4x))" << endl;
cout << "Bad exeample: ([x-y-z}*[x+2y)-{z+4x)]" << endl;
char * str = new char[81](); // STR
cin.getline(str, 81);
int index = 0;
while (str[index] != '\0')
{
index++;
}
if (str[index - 1] != ';') // CHECKING END STR
{
cout << "No see ==>> ;" << endl;
}
else
{
int i = 0, showMistakes = 0;
bool check = true;
char SMS = 'n';
//************************************************************************
// processing (
//************************************************************************
while (str[i] != '\0' && check == true)
{
if (str[i] == '(') // IF FOUND BRECKET
{
showMistakes = i + 1; // GET SHOW MISTAKES
stack.setElement(str[i]); // PUSH IN STACK
}
if (str[i] == ')') // IF FOUND BRECKET CLOSE GET OF STACK BRECKET OPEN
{
if (stack.getElement() == 0)
{
check = false;
}
}
i++;
}
if (stack.getElement() != 0)
{
check = false;
}
if (check == false)
{
cout << "error ==>> " << "\t";
i = 0;
SMS = 'y';
while (i != showMistakes)
{
cout << str[i];
i++;
}
cout << endl;
}
//************************************************************************
// processing {
//************************************************************************
i = 0;
showMistakes = 0;
while (str[i] != '\0' && check == true)
{
if (str[i] == '{')
{
showMistakes = i + 1;
stack.setElement(str[i]);
}
if (str[i] == '}')
{
if (stack.getElement() == 0)
{
check = false;
}
}
i++;
}
if (stack.getElement() != 0)
{
check = false;
}
if (check == false && SMS == 'n')
{
cout << "error ==>> " << "\t";
SMS = 'y';
i = 0;
while (i != showMistakes)
{
cout << str[i];
i++;
}
cout << endl;
}
//************************************************************************
// processing [
//************************************************************************
i = 0;
showMistakes = 0;
while (str[i] != '\0' && check == true)
{
if (str[i] == '[')
{
showMistakes = i + 1;
stack.setElement(str[i]);
}
if (str[i] == ']')
{
if (stack.getElement() == 0)
{
check = false;
}
}
i++;
}
if (stack.getElement() != 0)
{
check = false;
}
if (check == false && SMS == 'n')
{
cout << "error ==>> " << "\t";
i = 0;
while (i != showMistakes)
{
cout << str[i];
i++;
}
cout << endl;
}
//************************************************************************
if (check == true)
{
cout << "good" << endl;
}
}
delete[] str; // CLEAR STR
cout << endl;
STOP_CMD // CONST CMD SYSTEM PAUSE
return 0;
}
