Awesome
LinkedList
This library was developed targeting Arduino
applications. However, works just great with any C++.
Implementing a buffer for objects takes time. If we are not in the mood, we just create an array[1000]
with enough size.
The objective of this library is to create a pattern for projects.
If you need to use a List of: int
, float
, objects
, Lists
or Wales
. This is what you are looking for.
With a simple but powerful caching algorithm, you can get subsequent objects much faster than usual. Tested without any problems with Lists bigger than 2000 members.
Installation
- Download the Latest release from gitHub.
- Unzip and modify the Folder name to "LinkedList" (Remove the '-version')
- Paste the modified folder on your Library folder (On your
Libraries
folder inside Sketchbooks or Arduino software). - Reopen the Arduino software.
If you are here, because another Library requires this class, just don't waste time reading bellow. Install and ready.
Tests
cd
to this directory and run g++ -std=c++14 extras/test/tests.cpp -o tests && ./tests
Getting started
The LinkedList
class
In case you don't know what a LinkedList is and what it's used for, take a quick look at Wikipedia::LinkedList before continuing.
To declare a LinkedList object
// Instantiate a LinkedList that will hold 'integer'
LinkedList<int> myLinkedList = LinkedList<int>();
// Or just this
LinkedList<int> myLinkedList;
// But if you are instantiating a pointer LinkedList...
LinkedList<int> *myLinkedList = new LinkedList<int>();
// If you want a LinkedList with any other type such as 'MyClass'
// Make sure you call delete(MyClass) when you remove!
LinkedList<MyClass> *myLinkedList = new LinkedList<MyClass>();
Getting the size of the linked list
// To get the size of a linked list, make use of the size() method
int theSize = myList.size();
// Notice that if it's pointer to the linked list, you should use -> instead
int theSize = myList->size();
Adding elements
// add(obj) method will insert at the END of the list
myList.add(myObject);
// add(index, obj) method will try to insert the object at the specified index
myList.add(0, myObject); // Add at the beginning
myList.add(3, myObject); // Add at index 3
// unshift(obj) method will insert the object at the beginning
myList.unshift(myObject);
Getting elements
// get(index) will return the element at index
// (notice that the start element is 0, not 1)
// Get the FIRST element
myObject = myList.get(0);
// Get the third element
myObject = myList.get(2);
// Get the LAST element
myObject = myList.get(myList.size() - 1);
Changing elements
// set(index, obj) method will change the object at index to obj
// Change the first element to myObject
myList.set(0, myObject);
// Change the third element to myObject
myList.set(2, myObject);
// Change the LAST element of the list
myList.set(myList.size() - 1, myObject);
Deleting elements
// remove(index) will remove and return the element at index
// Remove the first object
myList.remove(0);
// Get and Delete the third element
myDeletedObject = myList.remove(2);
// pop() will remove and return the LAST element
myDeletedObject = myList.pop();
// shift() will remove and return the FIRST element
myDeletedObject = myList.shift();
// clear() will erase the entire list, leaving it with 0 elements
// NOTE: Clear wont DELETE/FREE memory from Pointers, if you
// are using Classes/Poiners, manualy delete and free those.
myList.clear();
Sorting elements
// Sort using a comparator function
myList.sort(myComparator);
Library Reference
ListNode
struct
-
T
ListNode::data
- The object data -
ListNode<T>
*next
- Pointer to the next Node
LinkedList
class
boolean
methods returns if succeeded
-
LinkedList<T>::LinkedList()
- Constructor. -
LinkedList<T>::~LinkedList()
- Destructor. Clear Nodes to minimize memory. Does not free pointer memory. -
int
LinkedList<T>::size()
- Returns the current size of the list. -
bool
LinkedList<T>::add(T)
- Add element T at the END of the list. -
bool
LinkedList<T>::add(int index, T)
- Add element T atindex
of the list. -
bool
LinkedList<T>::unshift(T)
- Add element T at the BEGINNING of the list. -
bool
LinkedList<T>::set(int index, T)
- Set the element atindex
to T. -
T
LinkedList<T>::remove(int index)
- Remove element atindex
. Return the removed element. Does not free pointer memory -
T
LinkedList<T>::pop()
- Remove the LAST element. Return the removed element. -
T
LinkedList<T>::shift()
- Remove the FIRST element. Return the removed element. -
T
LinkedList<T>::get(int index)
- Return the element atindex
. -
void
LinkedList<T>::clear()
- Removes all elements. Does not free pointer memory. -
void
LinkedList<T>::sort(int (*cmp)(T &, T &))
- Sorts the linked list according to a comparator funcrion. The comparator should return < 0 if the first argument should be sorted before the second, and > 0 if the first argument should be sorted after the first element. (Same as howstrcmp()
works.) -
protected
int
LinkedList<T>::_size
- Holds the cached size of the list. -
protected
ListNode<T>
LinkedList<T>::*root
- Holds the root node of the list. -
protected
ListNode<T>
LinkedList<T>::*last
- Holds the last node of the list. -
protected
ListNode<T>*
LinkedList<T>::getNode(int index)
- Returns theindex
node of the list.
Version History
1.1 (2013-07-20)
: Cache implemented. Getting subsequent objects is now O(N). Before, O(N^2).1.0 (2013-07-20)
: Original release