list

#include "List.h"

List::List()
{
    head = nullptr;
}

void List::pushElem(float data)
{
    if (head == nullptr)
    {
        head = new Node(data);
    }
    else
    {
        Node* current = this->head;
        while (current->pNext != nullptr)
        {
            current = current->pNext;
        }
        current->pNext = new Node(data);
    }
}

void List::printElems()
{
    Node* current = this->head;
    while (current != nullptr)
    {
        cout << current->data << " ";
        current = current->pNext;
    }
}

//в цикле проходим по списку k раз
//в каждом проходе текущий элемент добавляем в конец списка
void List::relocElems(short k)
{
    Node* current = this->head;
    for (int i = 0; i < k; i++)
    {
        this->pushElem(current->data);
        current = current->pNext;
    }
    //после завершения работы цикла элемент с индексом [k+1] назначаем головой (head)
    //предыдущие элементы автоматически отсекаются
    head = current;
}

/*void List::replaceMaxMinElems()
{
    Node* current = this->head;
    int max = current->data;
    int min = current->data;
    int i = 0;
    int maxIndex = 0;
    int minIndex = 0;
    //в цикле проходим по списку, ищем наибольшее/наименьшее значение и запоминаем их
    //также запоминаем индексы элементов
    while (current != nullptr)
    {
        if (current->data > max)
        {
            max = current->data;
            maxIndex = i;
        }
        if (current->data < min)
        {
            min = current->data;
            minIndex = i;
        }
        current = current->pNext;
        i++;
    }
    i = 0;
    current = this->head;
    //присваиваем значение наибольшего элемента наименьшему и наоборот
    while (current != nullptr)
    {
        if (i == maxIndex)
            current->data = min;
        if (i == minIndex)
            current->data = max;
        current = current->pNext;
        i++;
    }
}
*/

void List::replaceMaxMinElems() {
    Node* current = this->head;
    Node* min = current;
    Node* max = current;
    Node* prev = nullptr;
    Node* prevMax = head;
    Node* prevMin = head;
    Node* nextMax;
    Node* nextMin;
    Node* temphead = head;

    //поиск предыдущих max/min и предыдшествующих им элементов
    while (current != nullptr)
    {
        if (current->data > max->data) {
            max = current;
            prevMax = prev;
        }
        if (current->data < min->data) {
            min = current;
            prevMin = prev;
        }
        prev = current;
        current = current->pNext;
    }

    //если максимальный элемент находится в голове списка,
    //то устанавливаем его в качестве новой временной головы списка
    if (max == head) {
        prevMax = NULL;
        temphead=min;
    }
    //аналогично для минимального
    if (min == head) {
        prevMin = NULL;
        temphead =max;
    }

    //элемент, следующий за максимальным/минимальным
    nextMax = max->pNext;
    nextMin = min->pNext;

    //если max стоит сразу после min
    if (max == nextMin) {
        max->pNext = min;
        min->pNext = nextMax;
        if (min != head)
            prevMin->pNext = max;
    }
    //если min стоит сразу после max
    else if (min == nextMax) {
        min->pNext = max;
        max->pNext = nextMin;
        if (max != head)
            prevMax->pNext = min;
    }

    //если min и max не стоят рядом
    else {
        if (min != head)
            prevMin->pNext = max;
        max->pNext = nextMin;
        if (max != head)
            prevMax->pNext = min;
        min->pNext = nextMax;
    }
    //устанавливаем временную голову в качестве головы списка
    head = temphead;
}


int main()
{
    List lst;
    float data;
    short sizeList;
    cout << "enter the size of the list" << endl;
    cin >> sizeList;
    for (int i = 0; i < sizeList; i++)
    {
        cout << "Enter the " << i + 1 << " element: ";
        cin >> data;
        lst.pushElem(data);
    }
    lst.printElems();
    cout << "\nenter how much elements you'd like to relocate" << endl;
    int k = 0;
    cin >> k;
    cout << "list with relocated elements" << endl;
    if (k!=0) lst.relocElems(k);
    lst.printElems();
    cout << "\nlist with replaced min/max elements"
        << endl;
    lst.replaceMaxMinElems();
    lst.printElems();
    return 0;
}