лабы / лаба 14 прога

#include <iostream>

using namespace std;

class F {

public:

char a, b;

F() {};

F(char aa, char bb) {

a = aa;

b = bb;

}

~F() {};

};

template <class T>

class Node {

public:

T material;

Node* next;

Node() {

next = nullptr;

}

};

template <class T>

class list {

protected:

int size;

Node<T>* begin;

public:

list() {

begin = nullptr;

}

~list() {};

void AddToBegin(T a) {

Node<T>* n = new Node<T>;

n->material = a;

n->next = begin;

begin = n;

}

void DeleteFirst() {

Node<T>* d = begin;

begin = begin->next;

delete d;

}

void printList() {

Node<T>* p = begin;

while (p != nullptr) {

cout << p->material << " ";

p = p->next;

}

cout << endl;

}

bool Equal(list<T>a, list<T>b) {

Node<T>* f = a.begin;

Node<T>* s = b.begin;

for (; ;) {

if (f->material != s->material) return false;

f = f->next;

s = s->next;

}

return true;

}

void printListMy() {

Node<T>* p = begin;

while (p != nullptr) {

cout << p->material.a << " " << p->material.b << endl;

p = p->next;

}

cout << endl;

}

int Size() {

return size;

}

void SortList() {

F temp;

Node<T>* b1 = begin;

Node<T>* b2 = begin;

while (b1 != nullptr) {

while (b2 != nullptr) {

if (b1->material.a < b2->material.a) {

temp = b1->material;

b1->material = b2->material;

b2->material = temp;

}

b2 = b2->next;

}

b1 = b1->next;

b2 = b1;

}

}

void find(char m, list<F> g) {

Node<T>* f2 = g.begin;

list <F> f;

while (f2 != nullptr) {

if ((int)f2->material.a >= (int)m) {

F temp(f2->material.a, f2->material.b);

f.AddToBegin(temp);

}

f2 = f2->next;

}

f.printListMy();

}

Node<T>* giveNode() {

return begin;

}

friend list <F>& operator+(list <F>& a, list <F>& b);

T& operator [](const int index);

};

template <typename T>

T& list <T>::operator [] (const int index) {

int counter = 0;

Node<T>* current = this->begin;

while (current != nullptr) {

if (counter == index) {

return current->material;

}

current = current->next;

counter++;

}

}

list<F>& operator+(list<F>& first, list<F>& second) {

Node<F>* Fr = second.giveNode();

while (Fr != nullptr) {

first.AddToBegin(Fr->material);

Fr = Fr->next;

}

return first;

}

list<F> d;

list<F> UserDelete(int pos1, int pos2, list<F>& end) { //pos1 откуда удаляем, pos2 сколько удаляем

int count = 0;

Node<F>* ss = end.giveNode();

while (count != pos1) {

d.AddToBegin(ss->material);

ss = ss->next;

count++;

}

count = 0;

while (count != pos2) {

ss = ss->next;

count++;

}

while (ss != nullptr) {

d.AddToBegin(ss->material);

ss = ss->next;

}

return d;

}

int main() {

/*part 1*/

/*task 1*/

list <F> first;

F A('a', 'b');

F B('c', 'd');

F C('e', 'f');

F D('g', 'h');

F E('i', 'j');

F G('k', 'l');

first.AddToBegin(A);

first.AddToBegin(B);

first.AddToBegin(C);

first.AddToBegin(D);

first.AddToBegin(E);

first.AddToBegin(G);

cout << "List 1: " << endl;

first.printListMy();

cout << endl;

/*task 2*/

first.DeleteFirst();

F H('m', 'n');

F I('o', 'p');

first.AddToBegin(H);

first.AddToBegin(I);

cout << "List 1.1: " << endl;

first.printListMy();

cout << endl;

/*task 3*/

list <F> second;

F AA('q', 'r');

F BB('s', 't');

F CC('u', 'v');

F DD('w', 'x');

F EE('y', 'z');

F GG('k', 'l');

second.AddToBegin(AA);

second.AddToBegin(BB);

second.AddToBegin(CC);

second.AddToBegin(DD);

second.AddToBegin(EE);

second.AddToBegin(GG);

cout << "List 2: " << endl;

second.printListMy();

cout << endl;

/*task 4*/

int temp = 0;

cout << "Enter number of elements you want to delete" << endl;

cin >> temp;

for (int i = 0; i < temp; ++i) {

first.DeleteFirst();

}

cout << "List 1 after deleting: " << endl;

first.printListMy();

cout << "List 1 + List 2: " << endl;

list <F> c;

c = first + second;

c.printListMy();

/*part 2*/

/*task 1*/

cout << "Sorted list: " << endl;

c.SortList();

c.printListMy();

cout << endl;

/*task 2*/

list <F> buf1;

char i;

cout << "Enter the element more than you want to find" << endl;

cin >> i;

cout << "The elements were found: " << endl;

buf1.find(i, c);

cout << endl;

}