Lista Ligada

[angeljonh]

Implementar los siguientes métodos:
- T posición(unsigned int p);
- T operator[ ](unsigned int p) // sobrecargar del operador de acceso

El método anterior y la sobrecarga retornan el elemento "T" que almacena el Nodo en su campo "dato" de acuerdo a la posición que ocupa el nodo dentro de la lista ligada. Si una posición hace referencia a un nodo que no existe, lanzar excepción.

tengo este código que puedo hacer.


.h

Código [Seleccionar] Expandir

#ifndef LISTASIMPLE_H
#define LISTASIMPLE_H
#include <iostream>

using namespace std;

template<class T>
class Nodo{
public:
    Nodo(T dato, Nodo *s = nullptr){
        this->dato = dato;
        this->siguiente = s;
    }

private:
    T dato;
    Nodo *siguiente;

    template <class>
    friend class ListaSimple;
};

template<class T>
class ListaSimple
{
public:
    ListaSimple();
    bool vacio();
    void insertar(const T &dato);
    void insertar_ultimo(const T &dato);
    void borrar();
    void borrar_final();
private:
    Nodo<T> *raiz;
};

template<class T>
ListaSimple<T>::ListaSimple(){
    raiz = nullptr;
}

template<class T>
bool ListaSimple<T>::vacio(){
    return raiz == nullptr;
}

template<class T>
void ListaSimple<T>::insertar_ultimo(const T &dato){
    Nodo<T> *nuevo = new Nodo<T>(dato);
    if(vacio()){
        raiz = nuevo;
    }
    else{
        Nodo<T> *temp = raiz;
        while (temp->siguiente != nullptr) {
            temp = temp->siguiente;
        }
        temp->siguiente = nuevo;
    }
}

template<class T>
void ListaSimple<T>::insertar(const T &dato){
    Nodo<T> *nuevo = new Nodo<T>(dato);
    if(vacio()){
        raiz= nuevo;
    }
    else{
        nuevo->siguiente = raiz;
        raiz = nuevo;
    }
}

template<class T>
void ListaSimple<T>::borrar(){
    if(!vacio()){
        Nodo<T> *temp = raiz;
        raiz = raiz->siguiente;
        delete temp;
    }
    else {
        throw out_of_range("Imposible eliminar: lista vacia");
    }
}

template<class T>
void ListaSimple<T>::borrar_final(){
    if(!vacio()){
        Nodo<T>*temp=raiz;
        if(temp->siguiente==nullptr){
            borrar();}
        else{
            // 2 o mas elementos.
            while (temp->siguiente->siguiente != nullptr) {
                temp = temp->siguiente;}
            delete temp->siguiente;
            temp->siguiente = nullptr;
        }
    }
    else{
        throw out_of_range("Imposible eliminar: lista vacia");
    }
}


#endif // LISTASIMPLE_H