Update Assignment

CTDL-GT/Assignment/UnrolledLinkedList.cpp

@@ -0,0 +1,223 @@
+#include "UnrolledLinkedList.h"
+
+void UnrolledLinkedList::add(int val)
+{
+    if (tail == nullptr) {
+        tail = new Node(nodeSize);
+        ++numOfNodes;
+        head = tail;
+    } else if (tail->isFull()) {
+        Node *newNode = new Node(nodeSize);
+        ++numOfNodes;
+        newNode->prev = tail;
+        tail->next = newNode;
+        int hsize = getHalfNodeSize();
+        memmove(newNode->elements, tail->elements + hsize, (nodeSize - hsize) * sizeof(int));
+        tail->numElements = hsize;
+        newNode->numElements = nodeSize - hsize;
+        tail = newNode;
+    }
+    tail->add(val);
+    ++size;
+}
+
+int UnrolledLinkedList::getAt(int pos)
+{
+    if (pos < 0 || pos >= size)
+        throw "IndexOutOfBoundsException";
+    int cnt = 0;
+    Node *temp = head;
+    while (cnt + temp->numElements <= pos) {
+        cnt += temp->numElements;
+        temp = temp->next;
+    }
+    return temp->elements[pos - cnt];
+}
+
+void UnrolledLinkedList::setAt(int pos, int val)
+{
+    if (pos < 0 || pos >= size)
+        throw "IndexOutOfBoundsException";
+    int cnt = 0;
+    Node *temp = head;
+    while (cnt + temp->numElements <= pos) {
+        cnt += temp->numElements;
+        temp = temp->next;
+    }
+    temp->elements[pos - cnt] = val;
+}
+
+void UnrolledLinkedList::insertAt(int pos, int val)
+{
+    if (pos < 0 || pos > size)
+        throw "IndexOutOfBoundsException";
+    if (pos == size) {
+        add(val);
+        return;
+    }
+    int cnt = 0;
+    Node *temp = head;
+    while (cnt + temp->numElements <= pos) {
+        cnt += temp->numElements;
+        temp = temp->next;
+    }
+    if (temp->isFull()) {
+        Node *newNode = new Node(nodeSize);
+        ++numOfNodes;
+        if (temp == tail)
+            tail = newNode;
+        else
+            temp->next->prev = newNode;
+        newNode->prev = temp;
+        newNode->next = temp->next;
+        temp->next = newNode;
+        int hsize = getHalfNodeSize();
+        if (pos - cnt >= hsize) {
+            memmove(newNode->elements, temp->elements + hsize, (nodeSize - hsize) * sizeof(int));
+            temp->numElements = hsize;
+            newNode->numElements = nodeSize - hsize;
+            newNode->insertAt(pos - cnt - hsize, val);
+        } else {
+            memmove(newNode->elements, temp->elements + hsize - 1, (nodeSize - hsize + 1) * sizeof(int));
+            temp->numElements = hsize - 1;
+            newNode->numElements = nodeSize - hsize + 1;
+            temp->insertAt(pos - cnt, val);
+        }
+    } else {
+        temp->insertAt(pos - cnt, val);
+    }
+    ++size;
+}
+
+void UnrolledLinkedList::deleteAt(int pos)
+{
+    if (pos < 0 || pos >= size)
+        throw "IndexOutOfBoundsException";
+    int cnt = 0;
+    Node *temp = head;
+    while (cnt + temp->numElements <= pos) {
+        cnt += temp->numElements;
+        temp = temp->next;
+    }
+    temp->removeAt(pos - cnt);
+    --size;
+    if (size == 0) {
+        delete head;
+        --numOfNodes;
+        head = nullptr;
+        tail = nullptr;
+        return;
+    }
+    if (temp->isUnderHalfFull()) {
+        int hsize = getHalfNodeSize();
+        if (temp == head) {
+            Node *next = temp->next;
+            if (next != nullptr) {
+                if (next->numElements <= hsize) {
+                    memmove(temp->elements + temp->numElements, next->elements, next->numElements * sizeof(int));
+                    temp->numElements += next->numElements;
+                    temp->next = next->next;
+                    if (next == tail)
+                        tail = temp;
+                    else
+                        temp->next->prev = temp;
+                    delete next;
+                    --numOfNodes;
+                } else {
+                    temp->add(next->elements[0]);
+                    next->removeAt(0);
+                }
+            }
+        } else {
+            Node *prev = temp->prev;
+            if (prev->numElements <= hsize) {
+                memmove(prev->elements + prev->numElements, temp->elements, temp->numElements * sizeof(int));
+                prev->numElements += temp->numElements;
+                prev->next = temp->next;
+                if (temp == tail)
+                    tail = prev;
+                else
+                    prev->next->prev = prev;
+                delete temp;
+                --numOfNodes;
+            } else {
+                temp->insertAt(0, prev->elements[prev->numElements - 1]);
+                prev->removeAt(prev->numElements - 1);
+            }
+        }
+    }
+}
+
+int UnrolledLinkedList::firstIndexOf(int val)
+{
+    int cnt = 0;
+    Node *temp = head;
+    while (temp != nullptr) {
+        for (int i = 0; i < temp->numElements; ++i) {
+            if (temp->elements[i] == val)
+                return cnt + i;
+        }
+        cnt += temp->numElements;
+        temp = temp->next;
+    }
+    return -1;
+}
+
+int UnrolledLinkedList::lastIndexOf(int val)
+{
+    int cnt = size;
+    Node *temp = tail;
+    while (temp != nullptr) {
+        cnt -= temp->numElements;
+        for (int i = temp->numElements - 1; i >= 0; --i) {
+            if (temp->elements[i] == val)
+                return cnt + i;
+        }
+        temp = temp->prev;
+    }
+    return -1;
+}
+
+bool UnrolledLinkedList::contains(int val)
+{
+    Node *temp = head;
+    while (temp != nullptr) {
+        for (int i = 0; i < temp->numElements; ++i) {
+            if (temp->elements[i] == val)
+                return true;
+        }
+        temp = temp->next;
+    }
+    return false;
+}
+
+void UnrolledLinkedList::reverse()
+{
+    if (size < 2)
+        return;
+    Node *temp = head;
+    while (temp != nullptr) {
+        Node *prev = temp->prev;
+        Node *next = temp->next;
+        temp->reverse();
+        temp->next = prev;
+        temp->prev = next;
+        temp = next;
+    }
+    temp = head;
+    head = tail;
+    tail = temp;
+}
+
+int *UnrolledLinkedList::toArray()
+{
+    int *arr = new int[size];
+    int cnt = 0;
+    Node *temp = head;
+    while (temp != nullptr) {
+        memcpy(arr + cnt, temp->elements, temp->numElements * sizeof(int));
+        cnt += temp->numElements;
+        temp = temp->next;
+    }
+    return arr;
+}