// helper method for recusively insertion
void Set::insert(ELEMENT_TYPE x, Elem *& node) {
if (node == 0){ // insert here
node = new Elem(x, 0, 0);
_size++;
}
// move to left
else if (x < node->info) {
insert(x, node->left);
}
// move to right
else if (x > node->info) {
insert(x, node->right);
}
if (height(node->left) - height(node->right) == 2) { // calculate load factor
if(x < node->left->info) // outside case //
rotateRight(node);
else // inside case
doubleRotateRight(node);
}
if (height(node->left) - height(node->right) == -2) { // calculate load factor
if (x > node->right->info) // outside case //
rotateLeft(node);
else // inside case
doubleRotateLeft(node);
}
node->height = max(height(node->left), height(node->right)) + 1; // update height
}
TreeNode * Tree::insert(GenericData * elem, TreeNode *tree) {
if(tree == NULL) {
tree = new TreeNode(elem, NULL, NULL);
}
else {
if(elem->getId() < tree->getElem()->getId()) {
tree->setLeft(insert(elem, tree->getLeft()));
if(height(tree->getLeft()) - height(tree->getRight()) > 1) {
if(elem->getId() < tree->getLeft()->getElem()->getId()) {
tree = singleRotateLeft(tree);
}
else {
tree = doubleRotateLeft(tree);
}
}
}
else if(elem->getId() > tree->getElem()->getId()) {
tree->setRight(insert(elem, tree->getRight()));
if(height(tree->getRight()) - height(tree->getLeft()) > 1) {
if(elem->getId() > tree->getRight()->getElem()->getId()) {
tree = singleRotateRight(tree);
}
else {
tree = doubleRotateRight(tree);
}
}
}
}
return tree;
}
template<class T1, class T2> void DS::map<T1, T2>::_insertAVL(node* current, node* prv, T1 key, T2 value) {
if(current == null){
current = new node();
current->value = value, current->key = key, current->parent = prv, current->leftHeight = current->rightHeight = 0;
if(prv) {
if(prv->key < key) prv->right = current, prv->rightHeight = 1;
else prv->left = current, prv->leftHeight = 1;
} else root = current;
return;
}
_insertAVL(current->key < key ? current->right : current->left, current, key, value);
current->rightHeight = current->right ? _max(current->right) + 1 : 0;
current->leftHeight = current->left ? _max(current->left) + 1 : 0;
int diff = abs(current->rightHeight - current->leftHeight);
node* tmp;
if(diff > 1) { // AVL tree policy is violated - :o - and needs balancing. :D
if(current->rightHeight > current->leftHeight) { // left-rotation
tmp = current->right;
if(tmp->rightHeight > tmp->leftHeight) { // single-rotation
singleRotateLeft(current);
}else { // double-rotation
doubleRotateLeft(current);
}
}else { // right rotation
tmp = current->left;
if(tmp->leftHeight > tmp->rightHeight) { // single-rotation
singleRotateRight(current);
}else { // double-rotation
doubleRotateRight(current);
}
}
}
}
// 查找节点
void find(Tree *tree, int val)
{
Tree *root = tree;
Tree *parentnode = NULL;
Tree *grandnode = NULL;
tree = tree->left;
while (tree) {
if (tree->val == val) {
break;
} else if (tree->val > val) {
tree = tree->left;
} else {
tree = tree->right;
}
}
if (tree && tree->val == val) {
parentnode = tree->parent;
while (parentnode->val != INT_MIN) {
grandnode = parentnode->parent;
if (grandnode->val == INT_MIN) {
if (parentnode->left == tree) {
singleRotateLeft(parentnode);
} else {
singleRotateRight(parentnode);
}
return;
} else {
if (grandnode->left == parentnode && parentnode->left == tree) {
singleRotateLeft(grandnode);
singleRotateLeft(parentnode);
} else if (grandnode->left == parentnode && parentnode->right == tree) {
doubleRotateLeft(grandnode);
} else if (grandnode->right == parentnode && parentnode->right == tree) {
singleRotateRight(grandnode);
singleRotateRight(parentnode);
} else if (grandnode->right == parentnode && parentnode->left == tree) {
doubleRotateRight(grandnode);
}
parentnode = tree->parent;
}
}
}
}
void Map<KEY, T>::insert(KEY k, T t, Elem *& cur, Elem * lastLeft) {
Elem * node;
if(cur->left && k < cur->key) { // insert at left.
node = cur->left;
insert(k, t, cur->left, cur);
} else if(!cur->rightThread && k > cur->key) { // insert at right.
node = cur->right;
insert(k, t, cur->right, lastLeft);
} else if (!cur->left && k < cur->key) { // insert at the left.
cur->left = new Elem(k, t, 0, cur);
node = cur->left;
_size ++;
} else { // insert at the right.
cur->rightThread = false;
cur->right = new Elem(k, t, 0, lastLeft);
node = cur->right;
_size ++;
}
if (height(cur->left, false) - height(cur->right, cur->rightThread) == 2) { // calculate load factor
if(k < cur->left->key) // outside case
rotateRight(cur);
else // inside case
doubleRotateRight(cur);
}
if (height(cur->left, false) - height(cur->right, cur->rightThread) == -2) { // calculate load factor
if (k > cur->right->key) // outside case
rotateLeft(cur);
else // inside case
doubleRotateLeft(cur);
}
cur->height = max(height(cur->left, false), height(cur->right, cur->rightThread)) + 1; // update height
}
// helper method for recusively removal
void Set::erase(ELEMENT_TYPE x, Elem *& node){
//Node not found
if (node == 0){
return;
}
else{
if(node->info < x){
erase(x, node->right);
}
else if(node->info > x){
erase(x, node->left);
}
else{
if(node->right == 0){
Elem * tmp = node->left;
delete node;
node = tmp;
_size--;
}
else if( node->left == 0){
Elem * tmp = node->right;
delete node;
node = tmp;
_size--;
}
else{
Elem * tmp = node->right;
while(tmp->left){
tmp = tmp->left;
}
node->info = tmp->info;
delete tmp;
_size--;
}
}
}
if(node){
if (height(node->left) - height(node->right) == 2) { // calculate load factor
if(height(node->left->left) >= height(node->left->right)){ // outside case //
rotateRight(node);
}
else{ // inside case
doubleRotateRight(node);
}
}
if (height(node->left) - height(node->right) == -2) { // calculate load factor
if (height(node->right->right) >= height(node->right->left)) // outside case //
rotateLeft(node);
else // inside case
doubleRotateLeft(node);
}
node->height = max(height(node->left), height(node->right)) + 1; // update height
}
}
