//��������������ʵ�� //������������ʾ�Ķ�����T int BiSearchT::CreateSubTree(BiTree &t,int *all,int i) {if((all[i]==0)||i>16) {t=NULL; return 1;} t=(BiNode *)malloc(sizeof(BiNode)); if(t==NULL) return 0; t->data=all[i]; CreateSubTree(t->l,all,2*i); CreateSubTree(t->r,all,2*i+1); }
void QuadTree::InsertSubTree(Sprite *obj){ QuadPosition pos = SubTreeThatContains( obj->GetWorldPosition() ); if(subtrees[pos]==NULL) CreateSubTree(pos); assert(subtrees[pos]!=NULL); subtrees[pos]->Insert(obj); }
void TreeAddKline(struct ServerBan *kptr) { char **hostv; char hostname[HOSTLEN + 1]; int hostpieces; assert(kptr != NULL); /* * So we don't destroy kptr->hostname, use another buffer */ memset(hostname, 0, sizeof(hostname)); strncpy_irc(hostname, kptr->hostname, HOSTLEN); hostpieces = BreakupHost(hostname, &hostv); if (IsSortable(hostpieces, hostv)) CreateSubTree(&KlineTree, NULL, kptr, hostpieces, hostv); else { fprintf(stderr, "HOSTNAME [%s] IS NOT SORTABLE\n", kptr->hostname); AddUnsortableKline(kptr); } MyFree(hostv); } /* TreeAddKline() */
static void CreateSubTree(struct Level **level, struct Level *parent, void *typeptr, int hostc, char **hostv) { struct Level *tmpnode; char *ch; if (hostc == 0) return; /* * First search the current level for an exact match * of hostv[hostc - 1]. - if found proceed to the next * level down from there. * We can't use IsOnLevel() here because we need an * exact match (strcasecmp) - we don't want stuff like * "c?m" and "com" being put in the same node. */ for (tmpnode = *level; tmpnode; tmpnode = tmpnode->nextpiece) { if (!strcasecmp(tmpnode->name, hostv[hostc - 1])) { /* * We have found a matching host piece on this * level - no need to allocate a new level * structure. Now we will recursively call * CreateSubTree() again using tmpnode->nextlevel * as the level pointer, indicating that we want * to see if the next lower index of hostv * (hostv[hostc - 2]) is in the next level. If so, * again recursively call CreateSubTree(). Eventually * we might reach a level that does not contain * the corresponding index of hostv[]. When that * happens, the loop will fail and we will * drop below to allocate a new level structure. * If that does not happen, we have an exact duplicate * of a previous I/K line, in which case hostc will * be 1, and we add typeptr to the node's list of * pointers (the username may differ). */ if (hostc == 1) LinkStructPointer(typeptr, &tmpnode); CreateSubTree(&tmpnode->nextlevel, tmpnode, typeptr, hostc - 1, hostv); return; } } /* * If we reach this point, one of two conditions must * be true. * 1) *level is NULL, which means we must initialize it * and then add our hostv[] index to it. * 2) The host piece hostv[hostc - 1] was not found * on this level - allocate a new structure for it. */ tmpnode = (struct Level *) MyMalloc(sizeof(struct Level)); memset(tmpnode, 0, sizeof(struct Level)); tmpnode->name = MyStrdup(hostv[hostc - 1]); if (parent) { tmpnode->prevlevel = parent; ++parent->SubNodes; ++parent->UnsearchedSubNodes; } for (ch = tmpnode->name; *ch; ++ch) { if (IsWild(*ch)) { tmpnode->flags |= LV_WILDCARD; break; } } if (hostc == 1) { /* * Since hostc is 1, this is the very last hostname piece * we need to add to the sub tree. This is the piece that * will contain a pointer to the corresponding Iline or * Kline structure, so SearchSubTree() will know when to * stop. * Now, it is quite possible that later on we will need to * add more host pieces past this current piece. For example, * suppose our tree looks like this after this call: * * com * | * varner -> [struct Iline *iptr (for @varner.com)] * * Then, suppose later we wish to add an Iline for * @koruna.varner.com. Our tree should then look like this: * * com * | * varner -> [struct Iline (for @varner.com)] * | * koruna -> [struct Iline (for @koruna.varner.com)] * * SearchSubTree() will then know that both levels are a * complete I/K line, and depending on how big the hostname * it is looking for, will know how deep to go. */ LinkStructPointer(typeptr, &tmpnode); } if (*level == NULL) { /* * Set the level to our newly allocated structure */ *level = tmpnode; } else { /* * The level already exists, and possibly has some * host pieces on it - add our new piece after * *level. For example, if the level originally looked * like: * * ... * | * "com" --> "net" --> "org" --> NULL * * It will now look like: * * ... * | * "com" --> tmpnode->name --> "net" --> "org" --> NULL */ tmpnode->nextpiece = (*level)->nextpiece; (*level)->nextpiece = tmpnode; } /* * We've just added hostv[hostc - 1] to the correct level, * but as long as hostc != 0, there are more host pieces * to add. Recursively call CreateSubTree() until there * are no more pieces to add. */ CreateSubTree(&tmpnode->nextlevel, tmpnode, typeptr, hostc - 1, hostv); } /* CreateSubTree() */