// 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 } }