LinkedList.h

Go to the documentation of this file.

#ifndef _LINKEDLIST_H_
#define _LINKEDLIST_H_

#include "Log.h"

template <class TYPE>
class LLNode {
        public:
                TYPE obj;
                LLNode *prev;
                LLNode *next;
};

template <class TYPE>
class LinkedList {
        public:
                LinkedList();
                virtual ~LinkedList();

                inline void clear();
                inline const unsigned int getCount();
                inline LLNode <TYPE> *getFirst();
                inline LLNode <TYPE> *getLast();
                inline LLNode <TYPE> *popFirst();
                inline void addFirst(const TYPE &object);
                inline void addLast(const TYPE &object);

                inline void addNodeFirst(LLNode <TYPE> *node);
                inline void addNodeLast(LLNode <TYPE> *node);
                inline void removeNode(LLNode <TYPE> *node);

        protected:
                unsigned int size;
                LLNode <TYPE> *first, *last;
};

template <class TYPE>
LinkedList<TYPE>::LinkedList() {
        size = 0;
        first = last = NULL;
}

template <class TYPE>
LinkedList<TYPE>::~LinkedList() {
        clear();
}

template <class TYPE>
void LinkedList<TYPE>::clear() {
        LLNode <TYPE> *node = first;

        while (node != NULL) {
                LLNode <TYPE> *delNode = node;
                node = node->next;
                delete delNode;
        }

        size = 0;
        first = last = NULL;
}

template <class TYPE>
const unsigned int LinkedList<TYPE>::getCount() {
        return size;
}

template <class TYPE>
LLNode <TYPE> *LinkedList<TYPE>::popFirst() {
        LLNode <TYPE> *node = new LLNode <TYPE> (*first);
        removeNode(first);
        return node;
}

template <class TYPE>
LLNode <TYPE> *LinkedList<TYPE>::getFirst() {
        return first;
}

template <class TYPE>
LLNode <TYPE> *LinkedList<TYPE>::getLast() {
        return last;
}

template <class TYPE>
void LinkedList<TYPE>::addFirst(const TYPE &object) {
        LLNode <TYPE> *node = new LLNode <TYPE>;
        node->obj = object;
        addNodeFirst(node);
}

template <class TYPE>
void LinkedList<TYPE>::addLast(const TYPE &object) {
        LLNode <TYPE> *node = new LLNode <TYPE>;
        node->obj = object;
        addNodeLast(node);
}

template <class TYPE>
void LinkedList<TYPE>::addNodeFirst(LLNode <TYPE> *node) {
        if (first == NULL) {
                first = node;
                last = node;
                node->prev = NULL;
                node->next = NULL;
        }
        else {
                first->prev = node;
                node->next = first;
                first = node;
                node->prev = NULL;
        }

        size++;
}

template <class TYPE>
void LinkedList<TYPE>::addNodeLast(LLNode <TYPE> *node) {
        if (last == NULL) {
                first = node;
                last = node;
                node->prev = NULL;
                node->next = NULL;
        }
        else {
                last->next = node;
                node->prev = last;
                last = node;
                node->next = NULL;
        }

        size++;
}

template <class TYPE>
void LinkedList<TYPE>::removeNode(LLNode <TYPE> *node) {
        if (node->prev == NULL) {
                first = node->next;
        }
        else {
                node->prev->next = node->next;
        }

        if (node->next == NULL) {
                last = node->prev;
        }
        else {
                node->next->prev = node->prev;
        }

        delete node;
        size--;
}

#endif

---