List mit 3 arrays

list.cpp

@@ -0,0 +1,142 @@
+#include <iostream>
+#include <assert.h>
+
+using namespace std;
+
+template <class T>
+class List {
+    private:
+        T* data;
+        int* next;
+        int* free;
+        int head;
+        int current;
+        int size;
+        int next_free;
+    public:
+        List(int size);
+        bool insert(T e);
+        bool remove();
+        bool find_first();
+        bool find_next();
+        bool find_prior();
+        bool full();
+        bool empty();
+        T retrieve();
+        void update(T e);
+};
+
+template <class T>
+List<T>::List(int size) : size(size), head(-1), current(-1), next_free(size-1) {
+    this->data = new T[size];
+    this->next = new int[size];
+    this->free = new int[size];
+    for(int i = 0; i < size; i++) {
+        this->next[i] = -1;
+        this->free[i] = i;
+    }
+}
+
+template <class T>
+bool List<T>::full() {
+    return (this->next_free == -1);
+}
+
+template <class T>
+bool List<T>::empty() {
+    return (this->head == -1);
+}
+
+template <class T>
+bool List<T>::insert(T e) {
+    if(this->full()) return false;
+    int p = this->free[next_free--];
+    this->data[p] = e;
+    if(this->empty()) {
+        this->head = p;
+    } else {
+        this->next[p] = this->next[this->current];
+        this->next[this->current] = p;
+    }
+    this->current = p;
+    return true;
+}
+
+template <class T>
+bool List<T>::find_prior() {
+    if(this->empty()) return false;
+    int p = this->head;
+    while(p!=-1 && this->next[p] != this->current) {
+        p = this->next[p];
+    }
+    if(p == -1) {
+        return false;
+    } else {
+        this->current = p;
+        return true;
+    }
+}
+
+template <class T>
+bool List<T>::remove() {
+    if(this->empty()) return false;
+    int node_rem = this->current;
+    if(node_rem == this->head) {
+        this->head = this->next[node_rem];
+        this->current = this->head;
+    } else {
+        assert(this->find_prior());
+        this->next[this->current] = this->next[node_rem];
+    }
+    this->next[node_rem] = -1;
+    this->free[++this->next_free] = node_rem;
+    return true;
+}
+
+template <class T>
+bool List<T>::find_next() {
+    if(this->empty()) return false;
+    if(this->next[this->current] == -1) return false;
+    this->current = this->next[this->current];
+    return true;
+}
+
+template <class T>
+bool List<T>::find_first() {
+    if(this->empty()) return false;
+    this->current = this->head;
+    return true;
+}
+
+template <class T>
+T List<T>::retrieve() {
+    assert(!this->empty());
+    return this->data[current];
+}
+
+template <class T>
+void List<T>::update(T e) {
+    assert(!this->empty());
+    this->data[current] = e;
+}
+
+int main( int argc, char *argv[] ) {
+	List<int> l(20);
+    int i;
+    for(i = 0; !l.full(); i++) {
+        l.insert(i);
+    }
+    assert(i == 20);
+    assert(l.find_first());
+    while(l.find_next()) {
+        cout << l.retrieve() << endl;
+    }
+
+    assert(l.find_first());
+    while(!l.empty()) l.remove();
+
+
+    assert(!l.find_first());
+
+	return 0;
+}