Флаг компилятора для выбора версии стандарта

#include <iostream>
#include <memory>
 
using namespace std;
 
template<typename T>
class LinkedList {
 
public:
 
    class Data {
    public:
        explicit Data(const T &parameter) {
            data = parameter;
        }
 
        ~Data() {
            cout << "Structure with data -> " << this->data << " being deleted" << endl;
        }
 
        T data;
        std::shared_ptr<Data> next;
        std::shared_ptr<Data> prev;
        int index;
    };
 
    LinkedList() {
        list_size = 0;
        first = nullptr;
        last = nullptr;
    }
 
    LinkedList(std::initializer_list<T> lst) {
        list_size = 0;
        for (auto i : lst) addElement(i);
    }
 
    ~LinkedList() {
        cout << "List being deleted" << endl;
        if (size() > 1) {
            for (auto p = this->first->next; p != nullptr; p = p->next) {
                p->prev->next = nullptr;
                p->prev = nullptr;
            }
        }
        first = nullptr;
        last = nullptr;
        list_size = 0;
    }
 
    std::shared_ptr<Data> &operator[](int n) {
        int i = 0;
        for (std::shared_ptr<Data> buf = this->first; buf != nullptr; buf = buf->next, i++) {
            if (i == n) {
                //cout << "Element by index " << n << " is -> " << buf->data << endl;
                return buf;
            }
        }
        throw out_of_range("No element found!");
    }
 
    shared_ptr<Data> & addElement(T param);
 
    void deleteElements(T param);
 
    void delete_N_Element(int n);
 
    void refreshElement(T dest, T new_val);
 
    void addAfter_N_Element(T param, int n);
 
    void transferElementAfter_N_Element(int target, int dest);
 
    void print();
 
    int size() const {
        return list_size;
    }
 
    void sort() {
        quick_sort(0, size() - 1);
    }
 
    void quick_sort(int L, int R);
 
//    std::shared_ptr<typename LinkedList<T>::Data> addElement(std::shared_ptr<Data> obj);
 
private:
    int list_size;
    std::shared_ptr<Data> first;
    std::shared_ptr<Data> last;
 
 
};
 
template<typename T>
class SkipList {
public:
    SkipList(int levels, LinkedList<T> &list) {
        list_of_levels = new LinkedList<T>[levels];
        mainList = list;
        size = levels;
 
        if (list.size() != 0) {
            for (int i = 0; i < levels; i++) {
                for (int j = 0; j < list.size(); j++) {
                    if ((rand() % 2 + 1) == 2) {
                        list_of_levels[i].addElement(list[j]->data)->index = list[j]->index;
                    }
                }
            }
        }
    }
 
    ~SkipList() {
        delete [] list_of_levels;
    }
 
    void addElement(T param) { // добавляет элемент в главный список, затем вероятностно добавляет в списки выше
        auto &ptr = mainList.addElement(param);
        for (int i = 0; i < size; i++) {
            if ((rand() % 2 + 1) == 2) {
                auto &ptr_added = list_of_levels[i].addElement(param);
                ptr_added->index = ptr->index;
 
            }
        }
    }
 
    void deleteElement(T param)
    {
        //удаляет все элементы с заданным значением
        for (int i = 0; i < size; i++) {
            list_of_levels[i].deleteElements(param);
        }
 
        mainList.deleteElements(param);
    }
 
    std::shared_ptr<typename LinkedList<T>::Data> operator[](int n)
    {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < list_of_levels[i].size(); ++j) {
                if(n == list_of_levels[i][j]->index)
                    return list_of_levels[i][j];
            }
        }
        // если не нашли элемент на уровнях, то пробегаемся по главному списку
        for (int i = 0; i < size; i++)
        {
            if (n == mainList[i]->index)
                return mainList[i];
        }
        throw std::out_of_range("No element found!");
    }
 
    int findIndexForElement(T param)
    {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < list_of_levels[i].size(); ++j) {
                if (list_of_levels[i][j]->data == param)
                    return list_of_levels[i][j]->index;
            }
        }
        for (int i = 0; i < size; i++) {
            if (mainList[i]->data == param)
            return mainList[i]->index;
        }
        throw std::out_of_range("No element found!");
    }
 
    void print() { // выводит все уровни на экран: нижний список - главный
        for (int i = size - 1; i >= 0; i--) {
            if (list_of_levels[i].size() > 0)
                list_of_levels[i].print();
        }
        mainList.print();
    }
 
    int size;
    LinkedList<T> *list_of_levels;
    LinkedList<T> mainList;
};
 
template<typename T>
shared_ptr<typename LinkedList<T>::Data> & LinkedList<T>::addElement(T param) {
    std::shared_ptr<Data> ptr(new Data(param));
    if (size() == 0) {
        this->first = ptr;
        this->last = ptr;
        this->first->next = this->last;
        last->prev = this->first;
        ptr->index = 0;
    } else if (size() == 1) {
        this->last = ptr;
        ptr->prev = this->first;
        this->first->next = ptr;
        this->first->prev = nullptr;
    } else {
        this->last->next = ptr;
        ptr->prev = this->last;
        this->last = ptr;
    }
    this->list_size++;
    this->sort(); // авто-сортировка при добавлении элемента
 
    if (size() > 1) {
        int i = 0;
        for (auto buf = this->first; buf != nullptr; buf = buf->next, i++) { //переиндексируем элементы списка
            buf->index = i;
        }
    }
 
    return ptr;
}
 
template<typename T>
void LinkedList<T>::print() {
    if (size() > 0) {
        if (size() == 1)
        {
            std::cout << this->first->data << std::endl;
            return;
        }
        if (size() > 1) {
            for (auto buf = this->first; buf != nullptr; buf = buf->next) {
                std::cout << buf->data << " ";
            }
        }
        std::cout << std::endl;
    } else
    {
        std::cerr << "Элементов нет!" << std::endl;
    }
}
 
template<typename T>
void LinkedList<T>::addAfter_N_Element(T param, int n) {
    int i = 0;
    for (std::shared_ptr<Data> buf = this->first; buf != nullptr; buf = buf->next, i++) {
        if (i == n) {
            std::shared_ptr<Data> p(new Data(param));
            p->next = buf->next;
            buf->next = p;
            p->prev = buf;
 
            if (buf != this->last)
                p->next->prev = p;
 
            this->list_size++;
            return;
        }
    }
    throw std::out_of_range("Use addElement instead");
}
 
template<typename T>
void LinkedList<T>::deleteElements(T param) {
    //delete all elements with the specified value
    //overloaded == operator is needed
    int i = 0;
    for (std::shared_ptr<Data> buf = this->first; buf != nullptr && i < size(); buf = buf->next, i++) {
        if (buf->data == param) {
            if (this->first != buf)
                buf->prev->next = buf->next;
            else
                this->first = buf->next;
 
            if (this->last != buf)
                buf->next->prev = buf->prev;
            else
                this->last = buf->prev;
 
            this->list_size--;
        }
    }
}
 
template<typename T>
void LinkedList<T>::delete_N_Element(int n) {
    int i = 0;
    for (std::shared_ptr<Data> buf = this->first; buf != nullptr; buf = buf->next, i++) {
        if (i == n) {
            if (this->first != buf)
                buf->prev->next = buf->next;
            else
                this->first = buf->next;
 
            if (this->last != buf)
                buf->next->prev = buf->prev;
            else
                this->last = buf->prev;
 
            this->list_size--;
 
            if (size() > 1) {
                int i = 0;
                for (auto buf = this->first; buf != nullptr; buf = buf->next, i++) { //переиндексируем элементы списка
                    buf->index = i;
                }
            }
        }
    }
}
 
template<typename T>
void LinkedList<T>::transferElementAfter_N_Element(int target, int dest) {
    std::shared_ptr<Data> targ = (*this)[target], destination = (*this)[dest];
    this->delete_N_Element(target);
 
    targ->next = destination->next;
    destination->next = targ;
    targ->prev = destination;
 
    if (targ != this->last)
        destination->next->prev = destination;
 
}
 
template<typename T>
void LinkedList<T>::quick_sort(int L, int R) {
    T x = (*this)[(L + R) / 2]->data;
    int i = L, j = R;
    while (i <= j) {
        while ((*this)[i]->data < x) i++;
        while ((*this)[j]->data > x) j--;
 
        if (i <= j) {
            T buf = (*this)[i]->data;
            (*this)[i]->data = (*this)[j]->data;
            (*this)[j]->data = buf;
 
            i++;
            j--;
        }
    }
 
    if (L < j)
        quick_sort(L, j);
 
    if (i < R)
        quick_sort(i, R);
 
}
 
 
template <typename T>
void LinkedList<T>::refreshElement(T dest, T new_val) {
    //находит все элементы с заданным ключом и заменяет их на значение new_val, и пересортирует список
    //если элементов не находит, то изменений не вносится
    bool list_touched = false;
    int i = 0;
    for (auto buf = this->first; buf != nullptr && i < size(); buf = buf->next, i++) {
        if (buf->data == dest)
        {
            buf->data = new_val;
            list_touched = true;
        }
    }
 
    if (list_touched) this->sort();
}
 
 
int main() {
 
    srand(static_cast<unsigned int>(time(nullptr)));
 
    LinkedList<int> data;
 
//    for (int i = 0; i < 10; i++) {
//        data.addElement(rand() % 300 + 10);
//    }
 
    SkipList<int> sklist(3, data);
    sklist.addElement(999);
    sklist.addElement(666);
    sklist.addElement(555);
    sklist.deleteElement(555);
    sklist.addElement(444);
    sklist.print();
 
 
    cout << "Index for element 999 is -> " << sklist.findIndexForElement(999) << endl;
 
 
 
    return 0;
}