/*Delete the successor node of middle-parent order traversal*/
AVLTree
DeleteSuccessor(AVLTree T){
Position Tmp;
if(T->Left == NULL) /*The subtree has only one node*/
return T;
else /*Time to disable the miminal node*/
if(T->Left->Left == NULL){
Tmp = T->Left;
T->Left = T->Left->Right;
Tmp->Right = NULL;
/*Handle the height*/
T->Height = 1 + (MAX(Height(T->Left),Height(T->Right)));
return Tmp;
}
else
return DeleteSuccessor(T->Left);
}
/* Delete Node */
ptr_t DeleteTreeNode(data_t *myHeap, data_t *Master2SysAlloc, int *fixedStack, int *secondStack, int stackPtr_avl, ptr_t rootPtr, int key){
int flag_stop = 0;
int flag_stackIsUsed = 0;
ptr_t nowPtr = rootPtr;
struct stack_t stackOutput;
while(flag_stop == 0){
struct sub_t subResult = DeleteNodeSub(myHeap, nowPtr, key);
if(subResult.feedback == FB_DONE){
flag_stop = 1;
// --------- Deletion ---------
ptr_t leftPtr = node_get_left_pointer(myHeap, nowPtr);
ptr_t rightPtr = node_get_right_pointer(myHeap, nowPtr);
if(leftPtr == NULL_PTR || rightPtr == NULL_PTR){ // at least one null children
if(leftPtr != NULL_PTR){
struct node_t_std nowNode = node_read_std(myHeap, leftPtr);
node_write_std(myHeap, nowPtr, nowNode);
node_delete(Master2SysAlloc, leftPtr);
}else if(rightPtr != NULL_PTR){
struct node_t_std nowNode = node_read_std(myHeap, rightPtr);
node_write_std(myHeap, nowPtr, nowNode);
node_delete(Master2SysAlloc, rightPtr);
}else{
node_delete(Master2SysAlloc, nowPtr);
nowPtr = NULL_PTR;
}
}else{ // both leaves exists
//1.get the inorder successor
ptr_t rightPtr = node_get_right_pointer(myHeap, nowPtr);
ptr_t minPtr = minValueNode(myHeap, rightPtr);
//2.copy the inorder successor's data to this node
int copyData = node_read_data(myHeap, minPtr);
node_write_data(myHeap, nowPtr, copyData);
//3.delete the inorder successor
ptr_t tempPtr = DeleteSuccessor(myHeap, Master2SysAlloc, secondStack, 0, rightPtr, copyData);
node_set_right(myHeap, nowPtr, tempPtr);
}
// --------- Balancing ---------
if(flag_stackIsUsed == 0){
if(nowPtr == NULL_PTR){
rootPtr = nowPtr;
}else{
rootPtr = ProcessNodeDeletion(myHeap,nowPtr);
}
}else{
stackOutput = AVL_STACK_READ(fixedStack, stackPtr_avl);
stackPtr_avl = stackOutput.hdPtr_avl;
if(stackOutput.operation == GOING_LEFT){
node_set_left(myHeap, stackOutput.pointer, nowPtr);
}else{
node_set_right(myHeap, stackOutput.pointer, nowPtr);
}
while(stackPtr_avl > 0){
nowPtr = stackOutput.pointer;
ptr_t nowPtr_new = ProcessNodeDeletion(myHeap, nowPtr);
stackOutput = AVL_STACK_READ(fixedStack, stackPtr_avl);
stackPtr_avl = stackOutput.hdPtr_avl;
if(nowPtr_new != nowPtr){
if(stackOutput.operation == GOING_LEFT){
node_set_left(myHeap, stackOutput.pointer, nowPtr_new);
}else{
node_set_right(myHeap, stackOutput.pointer, nowPtr_new);
}
}
}
rootPtr = ProcessNodeDeletion(myHeap, stackOutput.pointer);
}
}else{
flag_stackIsUsed = 1;
if(subResult.feedback == FB_LEFT){
stackOutput = AVL_STACK_WRITE(fixedStack, stackPtr_avl, nowPtr, GOING_LEFT);
stackPtr_avl = stackOutput.hdPtr_avl;
nowPtr = node_get_left_pointer(myHeap, nowPtr);
}else{
stackOutput = AVL_STACK_WRITE(fixedStack, stackPtr_avl, nowPtr, GOING_RIGHT);
stackPtr_avl = stackOutput.hdPtr_avl;
nowPtr = node_get_right_pointer(myHeap, nowPtr);
}
if(nowPtr == NULL_PTR){
flag_stop = 1;
}
}
}
return rootPtr;
}
