lab4

///////////////////////////////////////////////////////////

#include <iostream>
#include <string.h>

using namespace std;

///////////////////////////////////////////////////////////

void strrev(char *str) {
        int i;
        int j;
        unsigned char a;
        unsigned len = strlen((const char *)str);

        for (i = 0, j = len - 1; i < j; i++, j--) {
            a = str[i];
            str[i] = str[j];
            str[j] = a;
        }
}

///////////////////////////////////////////////////////////

void itoa(int n, char s[], bool& minus) {
     int i = 0;

    // Если число отрицательное
    if (n < 0) {
        minus = true;
        n = -n;
    // Если число положительное
    } else {
        minus = false;
    }

    // Запись цифр
    // Пока цифр не останется
    do {
        s[i++] = (n % 10) + '0';  // Запись числа в строку
        n /= 10;                // Переход к следующему
    } while (n > 0);

    // Вставка символа окончания строки
    s[i] = '\0';
}

///////////////////////////////////////////////////////////

const int SZ = 100000; // Максимальный размер verylong

///////////////////////////////////////////////////////////

class verylong {
    private:

        char vlstr[SZ];  // Число в символах
        bool minus;      // Хранения знака минуса
        int vlen;        // Текущая длина

//---------------------------------------------------------

        // Конструктор с строкой
        verylong(const char s[SZ], bool symb) {
            strcpy(vlstr, s);

            minus = symb;
            vlen = strlen(s);

            // Избавляемся от юзлес нулей
            for (int i = vlen - 1; i > -1; i--) {
                if (vlstr[i] != '0' | i == 0 ) {
                    break;
                } else {
                    vlstr[i] = 0;
                }

            }

            // Избавляемся от юзлес минуса у нуля
            if (vlstr[0] == '0') {
                vlen = 1;
                minus = false;
            } else {
                minus = symb;
            }

            vlen = strlen(vlstr);
        }

//---------------------------------------------------------

    public:
        // Стандартный конструктор
        verylong() : vlen(0) { vlstr[0] = '\0'; }

        // Конструктор с числом
        verylong(const unsigned long n) {
            itoa(n, vlstr, minus);
            vlen = strlen(vlstr);
        }

//---------------------------------------------------------

        // Перегрузка оператор <<
        friend ostream& operator<< (ostream& stream, const verylong& obj) {
            char temp[SZ];
            strcpy(temp, obj.vlstr);
            strrev(temp);

            if (obj.minus) { stream << '-'; }



            return (stream << temp);
        }

//---------------------------------------------------------

        // Перегрузка оператора >>
        friend istream& operator>> (istream& stream, verylong& obj) {
            char temp_str[SZ];
            stream >> temp_str;
            obj.minus = false;
            obj.vlen = 0;

            // Перебор символов
            for (int i = 0; temp_str[i] != 0; i++) {
                // Проверка на минус
                if (temp_str[i] == '-') {
                    if (obj.vlen == 0) {
                        obj.minus = !(obj.minus);
                    } else {
                        exit(1);
                    }
                } else

                // Проверка на неправильный символ (не цифру)
                if (temp_str[i] < '0' | temp_str[i] > '9') {
                    exit(1);
                }

                // Запись цифры
                else {
                    obj.vlstr[obj.vlen++] = temp_str[i];
                }

            }

            obj.vlstr[obj.vlen] = 0;

            // Переворачиваем строку
            strrev(obj.vlstr);



            return stream;
        }

//---------------------------------------------------------

        // Оператор cравнения равенства (==)
        bool operator== (const verylong obj) const {
            // Проверка на разность знаков
            if (minus != obj.minus) { return false; }

            // Проверка на разность кол-во символов
            if (vlen != obj.vlen) { return false; }


            // Перебор всех разрядов
            for (int i = 0; i < vlen; i++) {

                int d1 = vlstr[i];
                int d2 = obj.vlstr[i];

                // Проверка на совпадение символа
                if (d1 != d2) { return false; }
            }

            return true;
        }


};


///////////////////////////////////////////////////////////

template <class T>
struct link {
    link* prev;  // Предыдущий элемент
    link* next;  // Следующий  элемент

    T data;  // Данные
};

///////////////////////////////////////////////////////////

template <class T>
class list {
    private:
        link<T>* first;
        link<T>* last;

        unsigned int count;

//---------------------------------------------------------

    public:
        // Дефолтный конструктор (без аргументов)
        list() : first(NULL) , last(NULL) , count(0)
            { /* ... */ }

//---------------------------------------------------------

        void push_back(const T& value){
            // Если Список не пустой
            if (count) {
                last -> next = new link<T>;
                last -> next -> prev = last;
                last = last -> next;
                last -> next = NULL;
                last -> data = value;
            }

            // Если Список пустой
            else {
                first = last = new link<T>;
                first -> prev = NULL;
                first -> next = NULL;
                first -> data = value;
            }

            count++;
        }

//---------------------------------------------------------

        friend void killerDublications(list<verylong>&);

//---------------------------------------------------------

        friend ostream& operator<< (ostream& stream, const list<T>& container) {
            for (auto iter_l = container.first; iter_l != NULL; iter_l = iter_l -> next) {
                stream << iter_l -> data << endl;
            }

            return stream;
        }

};

///////////////////////////////////////////////////////////

void killerDublications(list<verylong>& container) {
    for (auto iter_l = container.first; iter_l != NULL; iter_l = iter_l -> next) {
        for (auto iter_v = iter_l -> next; iter_v != NULL; iter_v = iter_v -> next) {
            if ( iter_l -> data == iter_v -> data ) {
                // Если удаляймый элемент - последний в контейнере
                if ((iter_v -> next) == NULL) {
                    container.last = container.last -> prev;
                    delete container.last -> next;
                    container.last -> next = NULL;
                }

                // Если удаляймый элемент - НЕ последний в контейнере
                else {
                    link<verylong>* temp = iter_v -> prev;
                    iter_v -> next -> prev = iter_v -> prev;
                    iter_v -> prev -> next = iter_v -> next;
                    delete iter_v;
                    iter_v = temp;
                }

            }
        }
    }
}

///////////////////////////////////////////////////////////

int main() {
    verylong tempVerylong;
    list<verylong> testList;

    for (int k = 0; k < 10; k++) {
        cout << "Input verylong [" << k + 1 << "/10]: "; cin >> tempVerylong;
        testList.push_back(tempVerylong);
    }

    cout << endl;

    killerDublications(testList);

    cout << "Result killerDublications():" << endl << testList << endl;




    return 0;
}

///////////////////////////////////////////////////////////