void o_t::orderRem(node * pos)
{
node * parent = pos ->up;
node * grand = pos ->up ->up;
if(grand == NULL)
{
if(parent != oroot)
{
printf("error in delete\n");
exit(0);
}
parent ->left = NULL;
}
else
{
node * other;
if(grand ->left == parent)
other = grand ->right;
else
other = grand ->left;
if(other == NULL)
printf("other is null\n");
grand ->height = other ->height;
grand ->left = other ->left;
grand ->right = other ->right;
grand ->left ->up = grand;
if(grand->right != NULL)
grand ->right ->up = grand;
int index = -1;
node ** stack = new node*[oroot ->height + 2];
while(grand ->up != NULL)
{
index ++;
stack[index] = grand ->up;
grand = grand ->up;
}
orderReb(stack ,index);
delete [] stack;
returnNode(other);
returnNode(parent);
}
if(pos == head)
head = head ->lnext;
else if(pos == tail)
tail = tail ->lprev;
returnNode(pos);
num --;
}
dScriptCompiler::dUserVariable dScriptCompiler::AddClassContructor (const dString& name, const dString& visibility)
{
dDAGClassNode* const curClass = GetCurrentClass();
dUserVariable typeVariable;
dAssert (name == curClass->m_name);
typeVariable.m_node = new dDAGTypeNode (m_allNodes, "void");
dUserVariable returnNode (AddClassFunction (typeVariable, name, "public static"));
curClass->m_constructors.Append((dDAGFunctionNode*)returnNode.m_node);
return returnNode;
}
dScriptCompiler::dUserVariable dScriptCompiler::ConcatenateVariables(const dUserVariable& classVariable, const dUserVariable& variable)
{
dUserVariable returnNode (variable);
dDAGExpressionClassVariable* const classVariableNode = (dDAGExpressionClassVariable*)classVariable.m_node;
dAssert (classVariableNode->GetTypeId() == dDAGExpressionClassVariable::GetRttiType());
dDAGExpressionNodeVariable* const nodeA = (dDAGExpressionNodeVariable*)classVariableNode->m_expression;
dDAGExpressionNodeVariable* const nodeB = (dDAGExpressionNodeVariable*)variable.m_node;
dAssert (nodeA->GetTypeId() == dDAGExpressionNodeVariable::GetRttiType());
dAssert (nodeB->GetTypeId() == dDAGExpressionNodeVariable::GetRttiType());
nodeB->SetType((dDAGTypeNode*)nodeA->m_type->Clone(m_allNodes));
nodeB->InitParam (*nodeA);
return returnNode;
}
dScriptCompiler::dUserVariable dScriptCompiler::AddClassVariable (const dString& modifiers, const dUserVariable& type, const dString& name)
{
/*
dUserVariable variableName(NewVariableStatement (name, modifiers));
dDAGParameterNode* const variableNameNode = (dDAGParameterNode*)variableName.m_node;
dAssert (variableNameNode->IsType(dDAGParameterNode::GetRttiType()));
dDAGTypeNode* const typeNode = (dDAGTypeNode*)type.m_node;
dAssert (typeNode->GetTypeId() == dDAGTypeNode::GetRttiType());
variableNameNode->SetType(typeNode);
dDAGClassNode* const curClass = GetCurrentClass();
curClass->AddVariable(variableNameNode);
*/
dUserVariable returnNode (NewExpressionNodeVariable (name, modifiers));
dAssert (returnNode.m_node->GetTypeId() == dDAGExpressionNodeVariable::GetRttiType());
dDAGExpressionNodeVariable* const node = (dDAGExpressionNodeVariable*) returnNode.m_node;
node->SetType((dDAGTypeNode*)type.m_node);
return returnNode;
}
dScriptCompiler::dUserVariable dScriptCompiler::NewVariableToCurrentBlock (const dString& modifiers, const dUserVariable& type, const dString& name)
{
dUserVariable variableName(NewVariableStatement (name, modifiers));
dDAGParameterNode* const variableNameNode = (dDAGParameterNode*)variableName.m_node;
dAssert (variableNameNode->IsType(dDAGParameterNode::GetRttiType()));
dDAGTypeNode* const typeNode = (dDAGTypeNode*)type.m_node;
dAssert (typeNode->GetTypeId() == dDAGTypeNode::GetRttiType());
variableNameNode->SetType(typeNode);
dAssert (m_scopeStack.GetCount());
dDAGScopeBlockNode* const block = GetCurrentScope();
block->AddStatement(variableNameNode);
dUserVariable returnNode (NewExpressionNodeVariable (name, modifiers));
dAssert (returnNode.m_node->GetTypeId() == dDAGExpressionNodeVariable::GetRttiType());
dDAGExpressionNodeVariable* const node = (dDAGExpressionNodeVariable*) returnNode.m_node;
node->SetType((dDAGTypeNode*) typeNode->Clone (m_allNodes));
return returnNode;
}
node * m_tree_t::removeNode(int index, int otherIndex)
{
node * upper, *other;
node *delNode = NULL;
num --;
node ** stack = new node*[num];
int sindex = -1;
if(root == NULL)
return NULL;
else if(root ->right == NULL)
{
if(index == root ->key)
{
node* pnode = root ->left;
root ->left = NULL;
root ->measure = 0;
root ->ep_l.clear();
root->ep_r.clear();
return pnode;
}
else return NULL;
}
else
{
node * pnode = root;
while(pnode ->right != NULL)
{
sindex ++;
stack[sindex] = pnode;
upper = pnode;
if(index < pnode ->key)
{
pnode = upper ->left;
other = upper ->right;
}
else
{
pnode = upper ->right;
other = upper ->left;
}//end of if-else
}//end of while
if(index == pnode ->key)
{
//printf("get the index %d , node %d\n",index, pnode ->left->key);
if(pnode ->left ->time == 1)
{
upper ->key = other ->key;
upper ->left = other -> left;
upper ->right = other ->right;
upper ->height = other ->height;
delNode = pnode ->left;
node * tmpN = pnode;
returnNode(tmpN ->left);
returnNode(other);
sindex --;
upper ->left ->nodeIvl_l = upper->nodeIvl_l;
if(upper ->right ==NULL)
upper ->left ->nodeIvl_r = upper ->nodeIvl_r;
else
{
upper ->left->nodeIvl_r = upper ->key;
upper ->right ->nodeIvl_l = upper ->key;
upper ->right ->nodeIvl_r = upper ->nodeIvl_r;
}
getLeftMin(upper);
getRightMax(upper);
getMeasure(upper);
}
else
{
pnode ->left -> time --;
if(index < otherIndex)
{
pnode->left->ep_r.remove(otherIndex);
pnode->left ->ep_l.remove(index);
}
else
{
pnode->left->ep_l.remove(otherIndex);
pnode->left->ep_r.remove(index);
}
pnode ->ep_l = pnode->left ->ep_l;
pnode ->ep_r = pnode ->left ->ep_r;
if(pnode->left->ep_l.size() != 0)
{
pnode ->left ->leftmin = pnode->left->ep_l.min();
}
else
pnode->left->leftmin = pnode->left->nodeIvl_l;
if(pnode->left->ep_r.size() != 0)
{
pnode ->left ->rightmax = pnode ->left->ep_r.max();
}
else
pnode->left ->rightmax = pnode ->left ->nodeIvl_r;
getLeftMin(pnode);
getRightMax(pnode);
getMeasure(pnode);
getLeftMin(upper);
getRightMax(upper);
getMeasure(upper);
}//end of else to process the case multiple endpoint
}
else
return NULL;
int aindex = sindex;
while(aindex > -1)
{
node * n = stack[aindex];
aindex --;
getLeftMin(n);
getRightMax(n);
getMeasure(n);
}
}//end of else
//rebalance
int finished = 0;
while(sindex > -1 && !finished)
{
int tmpHeight, oldHeight;
node * pnode = stack[sindex];
sindex --;
oldHeight = pnode ->height;
if(pnode->left->height - pnode ->right->height == 2)
{
if(pnode->left->left->height - pnode->right->height == 1)
{
rightR(pnode);
pnode ->right ->height = pnode ->right ->left ->height +1;
pnode ->height = pnode ->right ->height +1;
}
else
{
leftR(pnode ->left);
rightR(pnode);
tmpHeight = pnode ->left ->left ->height;
pnode ->left ->height = tmpHeight +1;
pnode ->right ->height = tmpHeight +1;
pnode ->height = tmpHeight +2;
}
}
else if(pnode->left->height - pnode->right->height == -2)
{
if(pnode ->right ->right ->height - pnode->left->height == 1)
{
leftR(pnode);
pnode ->left ->height = pnode->left ->right ->height +1;
pnode ->height = pnode ->left ->height +1;
}
else
{
rightR(pnode->right);
leftR(pnode);
tmpHeight = pnode ->right ->right ->height;
}
}
else
{
if(pnode->left->height > pnode->right->height)
pnode->height = pnode ->left ->height +1;
else
pnode ->height = pnode ->right ->height +1;
}
if(pnode -> height == oldHeight)
finished =1;
}// end of while for rebalance
return delNode;
}
int m_tree_t::insertNode(int index, int otherIndex)
{
node * newNode = getNode();
newNode ->height = 0;
newNode ->left = NULL;
newNode ->right = NULL;
newNode ->time = 1;
newNode ->key = index;
newNode ->ep_l.clear();
newNode ->ep_r.clear();
if(index < otherIndex)
//newNode ->ep_r.insert(otherIndex);
newNode ->ep_r.add(otherIndex);
else
//newNode ->ep_l.insert(otherIndex);
newNode ->ep_l.add(otherIndex);
node ** stack = new node* [num];
int sindex = -1;
node *pnode = NULL;
if(root ->left == NULL)
{
root ->left =newNode;
root ->key = index;
root ->right = NULL;
root ->height = 0;
newNode ->nodeIvl_l = root ->nodeIvl_l;
newNode ->nodeIvl_r = root ->key;
getLeftMin(root);
getRightMax(root);
getMeasure(root);
}
else
{
pnode = root;
while(pnode ->right != NULL)
{
sindex ++;
stack[sindex] = pnode;
if(index < pnode ->key)
pnode = pnode ->left;
else
pnode = pnode ->right;
}//end of while
if(index == pnode ->key)
{
//for the case there same endpoint
pnode ->left ->time ++;
returnNode(newNode);
// some ivtervals share the same endpoint, then I store the correspondence endpoint in vector (STL)
if(index <otherIndex)
{
pnode ->left ->ep_r.add(otherIndex);
pnode ->left ->rightmax = pnode->left->ep_r.max();
pnode ->rightmax = pnode ->left ->ep_r.max();
}
else
{
pnode ->left->ep_l.add(otherIndex);
pnode ->left ->leftmin = pnode->left->ep_l.min();
pnode ->leftmin = pnode ->left->ep_l.min();
}
pnode ->ep_l = pnode->left ->ep_l;
pnode ->ep_r = pnode ->left ->ep_r;
getLeftMin(pnode);
getRightMax(pnode);
getMeasure(pnode);
}
else
{
node * oldLeaf, *newLeaf;
oldLeaf = getNode();
oldLeaf->left = pnode ->left;
oldLeaf ->key = pnode ->key;
oldLeaf ->right = NULL;
oldLeaf ->height = 0;
newLeaf = getNode();
newLeaf ->left = newNode;
newLeaf ->key = index;
newLeaf ->right = NULL;
newLeaf ->height = 0;
newLeaf ->ep_l = newNode ->ep_l;
newLeaf ->ep_r = newNode ->ep_r;
oldLeaf ->ep_l = pnode ->ep_l;
oldLeaf ->ep_r = pnode ->ep_r;
if(pnode ->key <= index)
{
pnode ->left = oldLeaf;
pnode ->right = newLeaf;
pnode ->key = index;
}
else
{
pnode ->left = newLeaf;
pnode ->right = oldLeaf;
}
pnode ->height = 1;
pnode ->left ->nodeIvl_l = pnode ->nodeIvl_l;
pnode->left ->nodeIvl_r = pnode ->key;
getLeftMin(pnode->left);
getRightMax(pnode ->left);
getMeasure(pnode ->left);
pnode ->right ->nodeIvl_l = pnode ->key;
pnode -> right->nodeIvl_r = pnode ->nodeIvl_r;
getLeftMin(pnode ->right);
getRightMax(pnode ->right);
getMeasure(pnode ->right);
getLeftMin(pnode);
getRightMax(pnode);
getMeasure(pnode);
}//end of else
int tmpInx = sindex;
while(tmpInx > -1)
{
node* n = stack[tmpInx];
tmpInx --;
getLeftMin(n);
getRightMax(n);
getMeasure(n);
}
}// end of else
//rebalance the tree
int finished = 0;
while(sindex > -1 && !finished)
{
int tmpHeight, oldHeight;
node * ptrn = stack[sindex];
sindex --;
oldHeight = ptrn ->height;
//getMeasure(ptrn);
if(ptrn ->left ->height -ptrn->right ->height == 2)
{
if(ptrn->left->left->height - ptrn->right->height ==1)
{
rightR(ptrn);
ptrn->right->height = ptrn ->right ->left ->height +1;
ptrn ->height = ptrn->right ->height +1;
}
else
{
leftR(ptrn->left);
rightR(ptrn);
tmpHeight = ptrn ->left ->left ->height;
ptrn ->left ->height = tmpHeight +1;
ptrn ->right ->height = tmpHeight +1;
ptrn ->height = tmpHeight +2;
}
}
else if(ptrn->left->height - ptrn->right->height == -2)
{
if(ptrn->right->right->height - ptrn->left->height ==1 )
{
leftR(ptrn);
ptrn ->left ->height = ptrn ->left ->right ->height +1;
ptrn ->height = ptrn ->left ->height +1;
}
else
{
rightR(ptrn ->right);
leftR(ptrn);
tmpHeight = ptrn ->right ->right ->height;
ptrn ->left ->height = tmpHeight +1;
ptrn ->right ->height = tmpHeight +1;
ptrn ->height = tmpHeight +2;
}
}
else
{
if(ptrn ->left ->height > ptrn ->right ->height)
ptrn->height = ptrn ->left ->height +1;
else
ptrn ->height = ptrn ->right ->height +1;
}
if(ptrn ->height == oldHeight)
finished = 1;
}//end of while
//release the space for the stack
delete stack;
//increase the number for totall elements
return num ++;
}
