void nodeInsert(node* p, node* v)
{
if(v->x - p->x > 0){
/* east */
if(v->y-p->y > 0){
/* northeast */
if(p->cnodeNE != NULL){
nodeInsert(p->cnodeNE,v);
}
else{
p->cnodeNE = v;
p->cnodeNE->pnode = p;
}
}
else{
/* southeast */
if(p->cnodeSE != NULL){
nodeInsert(p->cnodeSE,v);
}
else{
p->cnodeSE = v;
p->cnodeSE->pnode = p;
}
}
}
else{
/* west */
if(v->y-p->y > 0){
/* northwest */
if(p->cnodeNW != NULL){
nodeInsert(p->cnodeNW,v);
}
else{
p->cnodeNW = v;
p->cnodeNW->pnode = p;
}
}
else{
/* southwest */
if(p->cnodeSW != NULL){
nodeInsert(p->cnodeSW,v);
}
else{
p->cnodeSW = v;
p->cnodeSW->pnode = p;
}
}
}
}
/*------------*/
void nodeRemove(node* v)
{
int nchild = nodeNchild(v);
int nquad = nodeQuadrant(v);
node* parent = v->pnode;
/* if node does not exist, exit */
if(!v){
return;
}
/* sever my tie with my parent */
switch(nquad)
{
case NE:
parent->cnodeNE = NULL;
break;
case NW:
parent->cnodeNW = NULL;
break;
case SW:
parent->cnodeSW = NULL;
break;
case SE:
parent->cnodeSE = NULL;
break;
}
/* if created orphans --> reinsert them */
if(nchild>0){
if(v->cnodeNE != NULL){
nodeInsert(parent,v->cnodeNE);
}
if(v->cnodeNW != NULL){
nodeInsert(parent,v->cnodeNW);
}
if(v->cnodeSW != NULL){
nodeInsert(parent,v->cnodeSW);
}
if(v->cnodeSE != NULL){
nodeInsert(parent,v->cnodeSE);
}
}
/* deallocate memory */
free(v);
}
Node* AvlTree::nodeInsert(Node* &rootNode , int data){
if (rootNode == NULL){
rootNode = new Node(NULL, NULL, data);
return rootNode;
}
if (data == rootNode->data){
return NULL;
}
if (data < rootNode -> data){
rootNode -> left = nodeInsert(rootNode->left, data);
rootNode -> height = MAX(Height(rootNode->left) , Height(rootNode -> right)) + 1;
int rightHeight = 0;
if (rootNode -> right != NULL){
rightHeight = rootNode -> right -> height;
}
if (Height(rootNode -> left) >= rightHeight + 2){
if (data < rootNode -> left -> data){
rootNode = LL(rootNode);
}else{
rootNode = LR(rootNode);
}
}
}else{
if (data > rootNode -> data){
rootNode -> right = nodeInsert(rootNode -> right, data);
rootNode -> height = 1 + MAX(Height(rootNode -> left) , Height(rootNode -> right));
int leftHeight = 0;
if (rootNode -> left != NULL){
leftHeight = rootNode -> left -> height;
}
if (Height(rootNode -> right) >= leftHeight + 2){
if (data > rootNode -> right -> data){
rootNode = RR(rootNode);
}else{
rootNode = RL(rootNode);
}
}
}
}
rootNode -> height = MAX(Height(rootNode -> left) , Height(rootNode -> right)) + 1;
return rootNode;
}
/*------------*/
void treeCreate(int npoin,double x[],double y[],double rad)
{
int i,j;
double xfind;
double yfind;
double rfind2;
node* inode;
inode = nodeCreate(x[0],y[0]);
mytree.root = inode;
id = id + 1;
/* put remaining points into tree */
for(i=1;i<npoin;i++)
{
inode = nodeCreate(x[i],y[i]);
nodeInsert(mytree.root,inode);
id = id + 1;
}
/* search for a point */
xfind = 0.34;
yfind = 0.1;
node* nget = NULL;
nodeGet(mytree.root,&nget,xfind,yfind);
if(nget != NULL){
xfind = nget->x;
yfind = nget->y;
rfind2 = nget->norm2;
}
else{
rfind2 = xfind*xfind + yfind*yfind;
}
nodeSeperation(mytree.root,xfind,yfind,rfind2,rad);
}
int main ()
{
FILE *inFile;
inFile = fopen("target/processed_output", "r");
if (inFile <= 0) {
fprintf(stdout, "Input File doesn't exist\n");
exit(-1);
}
int ret = 0;
Node *rootNode;
rootNode = calloc(1, sizeof(Node));
do
{
DataPointEntry *dpe;
dpe = calloc(1, sizeof(DataPointEntry));
ret = readDataPointFromFile(inFile, dpe);
if (ret > 0)
{
nodeInsert(rootNode, dpe, 0);
}
} while (ret > 0);
fclose(inFile);
FILE *outFile;
outFile = fopen("target/density_output", "w");
nodeTraverse(rootNode, 0, outFile, testCallBack);
fclose(outFile);
return 0;
}
// Insert n in pp. Returns true if pp needs rebalancing. false if not
bool TreeSetImpl::nodeInsert(TreeSetNode *&pp, TreeSetNode *n) {
TreeSetNode *p = pp;
if(!p) {
pp = p = n;
m_size++;
m_updateCount++;
return true;
}
const int c = m_comparator->cmp(p->m_key, n->m_key);
if(c > 0) { // pp.key > n.key. Insert n in left subtree.
if(!nodeInsert(p->m_left, n)) {
return false;
}
switch(p->m_balance) { // Left subtree has grown.
case 1 :
p->m_balance = 0;
return false;
case 0 :
p->m_balance = -1;
return true;
case -1: // Rebalance
{ TreeSetNode *p1 = p->m_left;
if(p1->m_balance == -1) { // Single LL rotation
p->m_left = p1->m_right;
p1->m_right = p;
p->m_balance = 0;
pp = p = p1;
} else { // Double LR rotation
TreeSetNode *p2 = p1->m_right;
p1->m_right = p2->m_left;
p2->m_left = p1;
p->m_left = p2->m_right;
p2->m_right = p;
p->m_balance = (p2->m_balance == -1) ? 1 : 0;
p1->m_balance = (p2->m_balance == 1) ? -1 : 0;
pp = p = p2;
}
p->m_balance = 0;
break;
}
}
return false;
}
if(c < 0) { // pp.key < n.key. Insert n in right subtree.
if(!nodeInsert(p->m_right, n)) {
return false;
}
switch(p->m_balance) { // Right subtree has grown.
case -1:
p->m_balance = 0;
return false;
case 0:
p->m_balance = 1;
return true;
case 1: // Rebalance
{ TreeSetNode *p1 = p->m_right;
if(p1->m_balance == 1) { // Single RR rotation
p->m_right = p1->m_left;
p1->m_left = p;
p->m_balance = 0;
pp = p = p1;
} else { // Double RL rotation
TreeSetNode *p2 = p1->m_left;
p1->m_left = p2->m_right;
p2->m_right = p1;
p->m_right = p2->m_left;
p2->m_left = p;
p->m_balance = (p2->m_balance == 1) ? -1 : 0;
p1->m_balance = (p2->m_balance == -1) ? 1 : 0;
pp = p = p2;
}
p->m_balance = 0;
break;
}
}
return false;
}
return false; // Duplicate key. Dont insert.
}
bool TreeSetImpl::insertNode(TreeSetNode *n) {
const size_t size = m_size;
nodeInsert(m_root, n);
return size != m_size;
}
