ListNode* mergeList(ListNode* l1, ListNode* l2) {
if (!l1)
return l2;
else if (!l2)
return l1;
ListNode* result = new ListNode(-1);
ListNode* last = result;
while (l1 && l2) {
if (l1->val < l2->val)
adjustNode(last, l1);
else
adjustNode(last, l2);
}
while (l1)
adjustNode(last, l1);
while (l2)
adjustNode(last, l2);
last->next = NULL;
last = result;
result = result->next;
delete last;
return result;
}
int delValFromNode(long long int val, struct btreeNode *myNode) {
int pos, flag = 0;
if (myNode) {
if (val < myNode->val[1]) {
pos = 0;
flag = 0;
} else {
for (pos = myNode->count;
(val < myNode->val[pos] && pos > 1); pos--);
if (val == myNode->val[pos]) {
flag = 1;
} else {
flag = 0;
}
}
if (flag) {
if (myNode->link[pos - 1]) {
copySuccessor(myNode, pos);
flag = delValFromNode(myNode->val[pos], myNode->link[pos]);
if (flag == 0) {
printf("Dado não encontrado na árvore\n");
}
} else {
removeVal(myNode, pos);
}
} else {
flag = delValFromNode(val, myNode->link[pos]);
}
if (myNode->link[pos]) {
if (myNode->link[pos]->count < MIN)
adjustNode(myNode, pos);
}
}
return flag;
}
/* delete val from the node */
int delValFromNode(int val, struct btreeNode *myNode) {
int pos, flag = 0;
if (myNode) {
if (val < myNode->val[1]) {
pos = 0;
flag = 0;
} else {
for (pos = myNode->count;
(val < myNode->val[pos] && pos > 1); pos--);
if (val == myNode->val[pos]) {
flag = 1;
} else {
flag = 0;
}
}
if (flag) {
if (myNode->link[pos - 1]) {
copySuccessor(myNode, pos);
flag = delValFromNode(myNode->val[pos], myNode->link[pos]);
if (flag == 0) {
printf("Given data is not present in B-Tree\n");
}
} else {
removeVal(myNode, pos);
}
} else {
flag = delValFromNode(val, myNode->link[pos]);
}
if (myNode->link[pos]) {
if (myNode->link[pos]->count < MIN)
adjustNode(myNode, pos);
}
}
return flag;
}
static void _deleteKey(BSTree* tree, BSNode* node, int key, int m)
{
int i, min = (int)ceil((float)m/2) - 1;
for(i = 1; i <= node->keyNum; ++i) {
if (node->keys[i] > key) {
node->keys[i-1] = node->keys[i];
node->values[i-1] = node->values[i];
}
}
node->keyNum -= 1;
if (node->keyNum < min)
adjustNode(tree, node);
}
static void adjustNode(BSTree* tree, BSNode* node)
{
if (node->parent == NULL) {
if (node->keyNum == 0) {
free(node);
tree->root = NULL;
}
return;
}
int index = indexNode(node);
int i, min = (int)ceil((float)tree->mOrder/2) - 1;
BSNode *right = NULL, *left = NULL, *p = node->parent;
int keyIndex;
if (index + 1 <= p->keyNum)
right = p->children[index + 1];
if (index >= 1)
left = p->children[index - 1];
//borrow from right
if (right && right->keyNum > min) {
keyIndex = index + 1;
node->values[node->keyNum+1] = p->values[keyIndex];
node->keys[node->keyNum+1] = p->keys[keyIndex];
if (right->children[0]) {
node->children[node->keyNum+1] = right->children[0];
right->children[0]->parent = node;
}
p->keys[keyIndex] = right->keys[1];
p->values[keyIndex] = right->values[1];
right->children[0] = right->children[1];
for(i = 2;i <= right->keyNum; ++i) {
right->keys[i-1] = right->keys[i];
right->values[i-1] = right->values[i];
right->children[i-1] = right->children[i];
}
right->keyNum -= 1;
node->keyNum += 1;
return;
}
//borrow from left
if (left && left->keyNum > min) {
keyIndex = index;
for(i = node->keyNum; i > 0; --i) {
node->keys[i+1] = node->keys[i];
node->values[i+1] = node->values[i];
node->children[i+1] = node->children[i];
}
node->children[1] = node->children[0];
node->values[1] = p->values[keyIndex];
node->keys[1] = p->keys[keyIndex];
if (left->children[left->keyNum]) {
node->children[0] = left->children[left->keyNum];
node->children[0]->parent = node;
}
p->keys[keyIndex] = left->keys[left->keyNum];
p->values[keyIndex] = left->values[left->keyNum];
left->keyNum -= 1;
node->keyNum += 1;
return;
}
//merge parent with right
if (right) { //right has more than one keys.
keyIndex = index + 1;
int j = node->keyNum + 1;
node->keys[j] = p->keys[keyIndex];
node->values[j] = p->values[keyIndex];
for(i = keyIndex +1; i <= p->keyNum; ++i) {
p->keys[i-1] = p->keys[i];
p->values[i-1] = p->values[i];
p->children[i-1] = p->children[i];
}
j++;
for(i = 1; i <= right->keyNum; ++i) {
node->keys[j] = right->keys[i];
node->values[j] = right->values[i];
node->children[j-1] = right->children[i-1];
if (node->children[j-1])
node->children[j-1]->parent = node;
j++;
}
node->children[j-1] = right->children[i-1];
if (node->children[j-1])
node->children[j-1]->parent = node;
free(right);
p->keyNum -= 1;
node->keyNum = j - 1;
if (p == tree->root && p->keyNum == 0) {
tree->root = node;
free(p);
return;
}
if (p->keyNum < min)
adjustNode(tree, p);
return;
}
//merge parent with left
keyIndex = index;
left->keys[left->keyNum+1] = p->keys[keyIndex];
left->values[left->keyNum+1] = p->values[keyIndex];
for(i = keyIndex +1; i <= p->keyNum; ++i) {
p->keys[i-1] = p->keys[i];
p->values[i-1] = p->values[i];
p->children[i-1] = p->children[i];
}
left->keyNum +=1;
p->keyNum -= 1;
free(node);
if (p == tree->root) {
tree->root = left;
free(p);
return;
}
if (p->keyNum < min)
adjustNode(tree, p);
}
