Algoritmi lezione 29 - Liste Concatenate con C++ 2

#include <iostream>
#include <memory>
#include <random>
#include <ctime>
#include <chrono>

using namespace std;
#include "../../vettori/min_max/utility_vettori.h"


template <typename T>
class ListaConcatenata {
private:
    // Nodo della lista_numeria
    class Nodo {
    public:
        T dati;

        std::unique_ptr<Nodo> successivo = nullptr;

      //Nodo(T i_dati) { dati = i_dati;}
        Nodo(T i_dati) : dati(i_dati) {}
    };

    std::unique_ptr<Nodo> testa = nullptr;
    Nodo* coda = nullptr;

public:
    ListaConcatenata() {}

    // Aggiunge un elemento all'inizio della lista
    void inserisci_in_testa(T i_dati) {
        auto nuovo = std::make_unique<Nodo>(i_dati);
        if (!testa) {
            coda = nuovo.get();
        }

        //std::cout << "testa PRIMA: " << testa.get() << std::endl;
        nuovo->successivo = std::move(testa);
        //std::cout << "testa DOPO: " << testa.get() << std::endl;

        testa = std::move(nuovo);
    }

    // Aggiunge un elemento alla fine della lista
    void inserisci_in_coda(T i_dati) {
        auto nuovo = std::make_unique<Nodo>(i_dati);
        if (!coda) {
            testa = std::move(nuovo);
            coda = testa.get();
        } else {
            coda->successivo = std::move(nuovo);
            coda = coda->successivo.get();
        }
    }

    // Stampa gli elementi della lista
    void stampa() const {
        Nodo* temp = testa.get();
        while (temp) {
            std::cout << temp->dati << " -> ";
            temp = temp->successivo.get();
        }
        std::cout << "nullptr" << std::endl;
    }

    // Rimuove il primo elemento con il i_dati specificati
    void elimina(T i_dati) {
        Nodo* temp = testa.get();
        Nodo* precedente = nullptr;

        // Se il nodo da rimuovere è la testa
        if (temp && temp->dati == i_dati) {
            testa = std::move(testa->successivo);
            if (!testa) {
                coda = nullptr;
            }
            return;
        }

        // Cerca il nodo da rimuovere
        while (temp && temp->dati != i_dati) {
            precedente = temp;
            temp = temp->successivo.get();
        }

        // Se il nodo non è stato trovato
        if (!temp) return;

        // Rimuove il nodo
        precedente->successivo = std::move(temp->successivo);
        if (!precedente->successivo) {
            coda = precedente;
        }
    }

    // Controlla se la lista è vuota
    bool vuota() const {
        return !testa;
    }

    bool inserisci_alla_posizione(int posizione, T i_dati)
    {
      int conta_nodi = 0;
      Nodo *temp = testa.get();

      if (posizione<0) return false;

      if (posizione == 0)
      {
        inserisci_in_testa(i_dati);
        return true;
      }
      else
      {
        while (temp && conta_nodi < posizione-1)
        {
          conta_nodi++;
          temp = temp->successivo.get();
        }

        if (temp)
        {
          auto nuovo = std::make_unique<Nodo>(i_dati);
          nuovo->successivo = std::move(temp->successivo);
          temp->successivo = std::move(nuovo);
          return true;
        }
        else
          return false;
      }

    }

};


int main() {
    ListaConcatenata<unsigned long> lista_numeri;

    lista_numeri.inserisci_in_coda(1);
    lista_numeri.inserisci_in_coda(2);
    lista_numeri.inserisci_in_coda(3);
    lista_numeri.inserisci_in_coda(4);



    lista_numeri.elimina(1);
    lista_numeri.elimina(4);
    lista_numeri.elimina(4);
    lista_numeri.elimina(2);
    lista_numeri.elimina(3);

    lista_numeri.inserisci_alla_posizione(-9, 999);
    lista_numeri.stampa();



   std::cout << "lista_numeri: ";
    lista_numeri.print_lista_numeri();

    return 0;
}