Update Assignment

CTDL-GT/Assignment02/TreeSet.cpp

@@ -0,0 +1,273 @@
+//use "balance" varialbe as "height"
+
+#include "TreeSet.h"
+
+static bool isSuccess;
+
+TreeSet::TreeSet()
+{
+    root = nullptr;
+    count = 0;
+}
+
+TreeSet::~TreeSet()
+{
+    clear();
+}
+
+void TreeSet::clearRec(AVLNode *root)
+{
+    if (root != nullptr) {
+        clearRec(root->left);
+        clearRec(root->right);
+        delete root;
+    }
+}
+
+void TreeSet::clear()
+{
+    clearRec(root);
+    root = nullptr;
+    count = 0;
+}
+
+int TreeSet::add(int val)
+{
+    isSuccess = false;
+    root = recursiveAdd(root, val);
+    if (isSuccess) {
+        ++count;
+        return true;
+    }
+    return false;
+}
+
+bool TreeSet::contains(int val)
+{
+    AVLNode *temp = root;
+    while (temp != nullptr) {
+        if (temp->key > val)
+            temp = temp->left;
+        else if (temp->key < val)
+            temp = temp->right;
+        else
+            return true;
+    }
+    return false;
+}
+
+void TreeSet::copy(const TreeSet &set)
+{
+    clear();
+    root = recursiveCopy(set.root);
+    count = set.count;
+}
+
+int TreeSet::first()
+{
+    if (root == nullptr) {
+        throw "NoSuchElementException";
+    }
+    AVLNode *temp = root;
+    while (temp->left != nullptr)
+        temp = temp->left;
+    return temp->key;
+}
+
+int TreeSet::last()
+{
+    if (root == nullptr) {
+        throw "NoSuchElementException";
+    }
+    AVLNode *temp = root;
+    while (temp->right != nullptr)
+        temp = temp->right;
+    return temp->key;
+}
+
+int TreeSet::higher(int val)
+{
+    if (root == nullptr)
+        return -1;
+    int higher = last();
+    if (val >= higher)
+        return -1;
+    AVLNode *temp = root;
+    while (temp != nullptr) {
+        if (temp->key > val) {
+            if (temp->key < higher)
+                higher = temp->key;
+            temp = temp->left;
+        } else {
+            temp = temp->right;
+        }
+    }
+    return higher;
+}
+
+int TreeSet::lower(int val)
+{
+    if (root == nullptr)
+        return -1;
+    int lower = first();
+    if (val <= lower)
+        return -1;
+    AVLNode *temp = root;
+    while (temp != nullptr) {
+        if (temp->key < val) {
+            if (temp->key > lower)
+                lower = temp->key;
+            temp = temp->right;
+        } else {
+            temp = temp->left;
+        }
+    }
+    return lower;
+}
+
+int TreeSet::remove(int val)
+{
+    isSuccess = false;
+    root = recursiveRemove(root, val);
+    if (isSuccess) {
+        --count;
+        return true;
+    }
+    return false;
+}
+
+
+TreeSet *TreeSet::subSet(int fromVal, int toVal)
+{
+    TreeSet *subSet = new TreeSet;
+    recursiveSubSet(subSet, root, fromVal, toVal);
+    return subSet;
+}
+
+int TreeSet::size()
+{
+    return count;
+}
+
+int TreeSet::getHeight(AVLNode *node)
+{
+    if (node == nullptr)
+        return 0;
+    return node->balance;
+}
+
+void TreeSet::setHeight(AVLNode *&node)
+{
+    node->balance = max(getHeight(node->left), getHeight(node->right)) + 1;
+}
+
+int TreeSet::getBalance(AVLNode *node)
+{
+    if (node == nullptr)
+        return 0;
+    return getHeight(node->left) - getHeight(node->right);
+}
+
+void TreeSet::recursiveSubSet(TreeSet *&subSet, AVLNode *node, int fromVal, int toVal)
+{
+    if (node == nullptr)
+        return;
+    if (node->key < fromVal) {
+        recursiveSubSet(subSet, node->right, fromVal, toVal);
+    } else if (node->key < toVal) {
+        subSet->add(node->key);
+        recursiveSubSet(subSet, node->left, fromVal, toVal);
+        recursiveSubSet(subSet, node->right, fromVal, toVal);
+    } else {
+        recursiveSubSet(subSet, node->left, fromVal, toVal);
+    }
+}
+
+AVLNode *TreeSet::recursiveAdd(AVLNode *&node, int val)
+{
+    if (node == nullptr) {
+        isSuccess = true;
+        return new AVLNode(val, 1);
+    }
+    if (node->key == val)
+        return node;
+    if (node->key > val)
+        node->left = recursiveAdd(node->left, val);
+    else
+        node->right = recursiveAdd(node->right, val);
+    setHeight(node);
+    return rebalance(node);
+}
+
+AVLNode *TreeSet::recursiveRemove(AVLNode *&node, int val)
+{
+    if (node == nullptr)
+        return node;
+    if (node->key > val) {
+        node->left = recursiveRemove(node->left, val);
+    } else if (node->key < val) {
+        node->right = recursiveRemove(node->right, val);
+    } else {
+        if (node->left == nullptr) {
+            AVLNode *temp = node->right;
+            delete node;
+            isSuccess = true;
+            return temp;
+        }
+        AVLNode *delNode = node->left;
+        while (delNode->right != nullptr)
+            delNode = delNode->right;
+        node->key = delNode->key;
+        node->left = recursiveRemove(node->left, node->key);
+    }
+    return rebalance(node);
+}
+
+AVLNode *TreeSet::recursiveCopy(AVLNode *node)
+{
+    if (node == nullptr)
+        return node;
+    AVLNode *temp = new AVLNode(node->key, node->balance);
+    temp->left = recursiveCopy(node->left);
+    temp->right = recursiveCopy(node->right);
+    return temp;
+}
+
+AVLNode *TreeSet::rotateLeft(AVLNode *&node)
+{
+    AVLNode *temp = node->right;
+    AVLNode *tmp = temp->left;
+    node->right = tmp;
+    temp->left = node;
+    setHeight(node);
+    setHeight(temp);
+    return temp;
+}
+
+AVLNode *TreeSet::rotateRight(AVLNode *&node)
+{
+    AVLNode *temp = node->left;
+    AVLNode *tmp = temp->right;
+    node->left = tmp;
+    temp->right = node;
+    setHeight(node);
+    setHeight(temp);
+    return temp;
+}
+
+AVLNode *TreeSet::rebalance(AVLNode *&node)
+{
+    if (node == nullptr)
+        return nullptr;
+    int balance = getBalance(node);
+    if (balance > 1) {
+        if (getBalance(node->left) < -1)
+            node->left = rotateLeft(node->left);
+        node = rotateRight(node);
+    } else if (balance < -1) {
+        if (getBalance(node->right) > 1)
+            node->right = rotateRight(node->right);
+        node = rotateLeft(node);
+    }
+    return node;
+}