27. Двусвязный список

template<typename T>
class line {

    template<typename T>
    class element {
    public:
        T data;
        element<T> *next_element, *previous_element;
        element(T data = T(), element<T> *next_element = nullptr, element<T> *previous_element = nullptr) {
            this->data = data;
            this->next_element = next_element;
            this->previous_element = previous_element;
        }
    };

    element<T> *first_element, *last_element;
    unsigned int Size;
public:

    line() {
        Size = 0;
        first_element = nullptr;
        last_element = nullptr;
    }

    void push_back(T data) {
        if (first_element == nullptr) {
            first_element = new element<T>(data);
        }
        else if (first_element != nullptr && last_element == nullptr) {
            last_element = new element<T>(data, nullptr, first_element);
            first_element->next_element = last_element;
        }
        else {
            last_element->next_element = new element<T>(data, nullptr, last_element);
            last_element = last_element->next_element;
        }
        Size++;
    }

    void pop_back() {
        if (Size != 0) {
            if (Size != 1) {
                element<T> *temp_adress;
                temp_adress = last_element->previous_element;
                delete last_element;
                last_element = temp_adress;
                temp_adress->next_element = nullptr;
            }
            else {
                delete first_element;
                first_element = nullptr;
            }
            Size--;
        }
    }

    int size() { return Size; }

    T& operator [](int index) {
        if (Size != 0) {
            unsigned int Count = 0;
            element<T> *temp_adress;
            if (index >= Size / 2 && index > 1) {
                temp_adress = last_element;
                while (Count != Size - index - 1) {
                    temp_adress = temp_adress->previous_element;
                    Count++;
                }
            }
            else {
                temp_adress = first_element;
                while (Count != index) {
                    if (temp_adress->next_element == nullptr) {
                        break;
                    }
                    temp_adress = temp_adress->next_element;
                    Count++;
                }
            }
            return temp_adress->data;
        }
        else { return index; }
    }

    void push_front(T data) {
        first_element = new element<T>(data, first_element, nullptr);
        first_element->next_element->previous_element = first_element;
        if (last_element == nullptr) {
            last_element = first_element->next_element;
        }
        Size++;
    }

    void pop_front() {
        if (Size != 0) {
            element<T> *temp_adress;
            if (last_element != nullptr) {
                first_element->next_element->previous_element = nullptr;
                temp_adress = first_element;
                if (last_element == first_element->next_element) {
                    last_element = nullptr;
                }
                first_element = first_element->next_element;
                delete temp_adress;
            }
            else {
                delete first_element;
                first_element == nullptr;
            }
            Size--;
        }
    }

    void clear() {
        while (Size != 0) {
            pop_front();
        }
    }

    void insert(T data, int index) {
        if (index <= Size) {
            if (index == 0) {
                push_front(data);
            }
            else if (index == Size) {
                push_back(data);
            }
            else {
                unsigned int Count = 0;
                element<T> *temp_adress;
                if (index >= Size / 2 && index > 1) {
                    temp_adress = last_element;
                    while (Count != Size - index - 1) {
                        temp_adress = temp_adress->previous_element;
                        Count++;
                    }
                }
                else {
                    temp_adress = first_element;
                    while (Count != index) {
                        if (temp_adress->next_element == nullptr) {
                            break;
                        }
                        temp_adress = temp_adress->next_element;
                        Count++;
                    }
                }
                temp_adress = new element<T>(data, temp_adress, temp_adress->previous_element);
                temp_adress->previous_element->next_element = temp_adress->next_element->previous_element = temp_adress;
                Size++;
            }
        }
    }

    void removeAt(int index) {
        if (index < Size) {
            if (index == 0) {
                pop_front();
            }
            else if (index == Size - 1) {
                pop_back();
            }
            else {
                unsigned int Count = 0;
                element<T> *temp_adress;
                if (index >= Size / 2 && index > 1) {
                    temp_adress = last_element;
                    while (Count != Size - index - 1) {
                        temp_adress = temp_adress->previous_element;
                        Count++;
                    }
                }
                else {
                    temp_adress = first_element;
                    while (Count != index) {
                        if (temp_adress->next_element == nullptr) {
                            break;
                        }
                        temp_adress = temp_adress->next_element;
                        Count++;
                    }
                }
                temp_adress->previous_element->next_element = temp_adress->next_element;
                temp_adress->next_element->previous_element = temp_adress->previous_element;
                delete temp_adress;
                Size--;
            }
        }
    }

    ~line() {
        clear();
    }
};