list

#ifndef LISTA_H_INCLUDED
#define LISTA_H_INCLUDED

#include <iostream>


template<typename T>
struct node
{
    T dato;
    node* nextNode;
    node* previousNode;

    node(const T& elem,node* next,node* previous):dato(elem),
    nextNode(next),previousNode(previous){}

};

template<typename T>
class lista
{
    size_t listSize;
    node<T>* listFront;
    node<T>* listBack;

public:
    lista()
    {
        listSize = 0;
        listFront = nullptr;
        listBack = nullptr;
    }
    ~lista()
    {

    }
    bool empty() const;
    size_t size() const;
    void push_front(const T& elem);
    void push_back(const T& elem);
    const T& front() const;
    const T& back() const;
    void pop_front();
    void pop_back();
    void sort();
    T& operator [](size_t idx) const;
};

template<typename T>
bool lista<T>::empty() const
{
    return listSize == 0;
}

template<typename T>
size_t lista<T>::size() const
{
    return listSize;
}

template<typename T>
void lista<T>::push_front(const T &elem)
{
    node<T>* inserted;
    if(empty())
    {
        inserted = new node(elem,listBack,listFront);
        listFront = inserted;
        listBack = inserted;

    }
    else
    {
       inserted = new node(elem, listBack, nullptr);
       listFront->previousNode = inserted;
       listFront = inserted;
    }
    ++listSize;
}

template<typename T>
void lista<T>::push_back(const T &elem)
{
    node<T>* inserted;
    if(empty())
    {
        inserted = new node(elem,listBack,listFront);
        listFront = inserted;
        listBack = inserted;

    }
    else
    {
       inserted = new node(elem, nullptr, listFront);
       listFront->nextNode = inserted;
       listFront = inserted;
    }
    ++listSize;
}

template<typename T>
const T &lista<T>::front() const
{
    if(empty())
        throw invalid_argument("esta vacia");
    return listFront->dato;
}

template<typename T>
const T &lista<T>::back() const
{
    if(empty())
        throw invalid_argument("esta vacia");
    return listBack->dato;
}

template<typename T>
void lista<T>::pop_front()
{
    if(empty())
        throw invalid_argument("Esta vacia");
    node<T>* eliminar = listFront;
    listFront = listFront->nextNode;
    if(listFront != nullptr)
        listFront->anterior = nullptr;
    delete eliminar;
    eliminar = nullptr;
    --listSize;
}

template<typename T>
void lista<T>::pop_back()
{
    if(empty())
        throw invalid_argument("Esta vacia");
    node<T>* eliminar = listBack;
    listBack = listBack->previousNode;
    if(listBack != nullptr)
        listBack->nextNode=nullptr;
    delete eliminar;
    eliminar = nullptr;
    --listSize;
}

template<typename T>
void lista<T>::sort()
{
    node<T> *temp = listFront;
    node<T> *sig = temp->nextNode;
    for (size_t k = 0; k < listSize - 1; ++k) {
        for (size_t i = 0; i < listSize - 1; ++i) {
            if (sig->dato < temp->dato){
                T auxiliar = temp->dato;
                temp->dato = sig->dato;
                sig->dato = auxiliar;
            }
            temp = temp->nextNode;
            sig = temp->nextNode;
        }
        temp = listFront;
        sig = temp->nextNode;
    }
}


template<typename T>
T &lista<T>::operator [](size_t idx) const
{
    if(empty())
        throw invalid_argument("Esta vacia");
    else if(idx >= listSize)
        throw invalid_argument("index fuera de rango");
    node<T>* temp = listFront;
    for(size_t i = 0; i < idx;++i)
        temp = temp->nextNode;
    return temp->dato;
}

#endif // LISTA_H_INCLUDED