//
// FindTransports
//
// Find a suitable list of transports for this squad
//
void Transport::Manager::FindTransports(Script &script)
{
// We have a number of slots we need (provided by the number of units in the squad)
// Use the transports closest to the squad first
U32 slots = script.GetSquad()->GetList().GetCount();
BinTree<Transport, F32> transports;
// Get the current location of the suqad
Vector location;
if (script.GetSquad()->GetLocation(location))
{
// Make sure that there's no dead transports lingering around
RemoveDeadTransports();
// Sort the transports by distance from the squad
for (NBinTree<Transport>::Iterator i(&idle); *i; i++)
{
transports.Add((location - (**i)->Origin()).Magnitude2(), *i);
}
// Now itereate the sorted transports and assign them to the script
for (BinTree<Transport, F32>::Iterator t(&transports); *t; t++)
{
Transport &transport = **t;
// Assign this transport to the script
transport.AssignToSquad(&script);
// How many slots does this transport provide ?
U32 available = transport->TransportType()->GetSpaces();
if (available >= slots)
{
slots = 0;
break;
}
// We still have slots to go .. keep looking
slots -= available;
}
// We're out of transports, did we get enough ?
if (slots)
{
// We didn't get enough, notify the script
script.Notify(0x3BBBD1F7); // "Transport::NotEnough"
}
else
{
// We got enough, notify the script
script.Notify(0x9BA84E05); // "Transport::Enough"
}
transports.UnlinkAll();
}
}
// ---------------------------------------------------------------------------
// addItem()
// Takes the Item and addes to the hash table using the movieCode as a key to
// hash function approiatly
bool Inventory::addItem(Item *item, char movieCode)
{
BinTree *storageTree = storage[hash(movieCode)];
storageTree->insert(item);
return true;
}
void testIterator ()
{
BinTree<int> t;
t.insertBOT(59)
.insertBOT(23)
.insertBOT(68)
.insertBOT(190)
.insertBOT(41)
.insertBOT(67);
BinTree<int>::LeftRootRightIterator it = t.begin();
assert (*it == 23);
++it;
++it;
assert (*it == 59);;
int count = 0;
for (it = t.begin(); it != t.end(); ++it)
{
count++;
}
assert (count == 6);
}
int main ()
{
testMember ();
testAssignment();
testMinEl();
testIterator();
BinTree<int> t;
t.insertBOT(56)
.insertBOT(23)
.insertBOT(68)
.insertBOT(190)
.insertBOT(41)
.insertBOT(60)
.insertBOT(65)
.insertBOT(59);
cerr << "digraph G{" << endl;
t.dottyPrint (cerr);
cerr << "}\n";
prettyPrint<int> (t.rootIter());
testMakeTree();
return 0;
}
// ---------------------------------------------------------------------------
// retrieveItem
// Takes the Item and compares it's value in the correct BinTree found after
// using itemCode to hash to correct key
Item* Inventory::retrieveItem(const Item *obj, char itemCode) const
{
BinTree *storageTree = storage[hash(itemCode)];
Item *retrieved = NULL;
storageTree->retrieve(obj, retrieved);
return retrieved;
}
// overloaded equality operator ==
bool BinTree::operator==(const BinTree &otherTree) const {
// case 1: both trees are empty
if ( isEmpty() && otherTree.isEmpty() ) {
return true;
} else if (isEmpty() || otherTree.isEmpty()){
return false;
} else {
return equalityHelper(root,otherTree.root);
}
}
void testMember ()
{
BinTree<int> t;
t.add(10,"").add(12,"L").add(14,"R").add(15,"LR");
assert (t.member(12) == true);
assert (t.member(18) == false);
assert (t.member(15) == true);
}
int main (int argc, char *argv[])
{
string treestr("one two three # # # four five six # seven # # # eight nine # # #\n");
istringstream sin(treestr);
BinTree<string> tree;
sin >> tree;
cout << tree << endl;
cout << "先序输出:" << endl;
cout << "0. ";
tree.preorder_traverse();
cout << "1. ";
tree.preorder_traverse_nore();
cout << "2. ";
tree.preorder_traverse_nore2();
cout << "3. ";
tree.preorder_traverse_nore3();
cout << "中序输出:" << endl;
cout << "1. ";
tree.inorder_traverse_nore();
cout << "2. ";
tree.inorder_traverse_nore2();
cout << "后序输出:" << endl;
tree.postorder_traverse();
cout << "层序输出:" << endl;
tree.levelorder_traverse();
return EXIT_SUCCESS;
} // ---------- end of function main ----------
int main()
{
FILE* f = fopen("example.txt", "r");
BinTree<char> tree;// = BinTree<char>();
Node<char>* pos = tree.Root;
add(f, pos, true);
tree.traverseInfix(tree.Root);
system("pause");
return 0;
}
int main()
{
BinTree<char> t;
t.input(v, 29);
// t.output();
// t.preorder_traversal();
// t.inorder_traversal();
// t.postorder_traversal();
t.print_path();
return 0;
}
void testMinEl ()
{
BinTree<int> t;
t.insertBOT(59)
.insertBOT(23)
.insertBOT(68)
.insertBOT(190)
.insertBOT(41)
.insertBOT(67);
assert (t.minelement() == 23);
}
void testMakeTree ()
{
BinTree<int> t;
typename BinTree<int>::HierarchicalIterator it = t.rootIter();
*it = 10;
*it.goLeft() = 12;
*it.goRight() = 14;
*it.goRight().goLeft() = 20;
prettyPrint<int> (it);
}
//
// Process a CreateCursor scope
//
void ProcessCreateCursor(FScope *fScope)
{
// Cursor name is first argument
const char *name = fScope->NextArgString();
// Cursor class is second argument
const char *cls = fScope->NextArgString();
// Create the cursor
Base *newCrs = NULL;
U32 key = Crc::CalcStr(cls);
switch (key)
{
case 0x5B2A0A5F: // "Null"
newCrs = new Base;
break;
case 0xE04B5BBC: // "Bitmap"
newCrs = new Bmp;
break;
case 0xE5A51519: // "Geometric"
newCrs = new Geometric;
break;
default:
{
Base *derived;
if ((derived = cursors.Find(key)) != NULL)
{
newCrs = new Derived(derived);
}
else
{
LOG_ERR(("Unknown Cursor Class [%s]", cls));
return;
}
break;
}
}
// Configure the cursor
newCrs->Configure(fScope);
// Add it to the list
cursors.Add(Crc::CalcStr(name), newCrs);
}
void Output(BinTree<char> &B)
{
int num;
MyQueue<char> Q;
B.InOrderInMirror(B.root,Show,Q);
int i=0;
char arr[DEFAULTSIZE];
B.PreOrder(B.root,arr,i);
while (!Q.IsEmpty())
{
num=NumCal(arr,Q.getFront());
for (i=1;i<num;i++) cout<<" ";
cout<<Q.DeQueue()<<endl;
}
}
int main()
{
char* str = "123##4##5#6###";
char* str1 = "23##5###";
char* str2 = "472##5##8##";
BinTree<char> mytree;
BinTree<char> rtree;
mytree.createTree(str2);
// rtree.createTree(str1);
// mytree.mirrorTree();
mytree.preOrder();
mytree.sumData(12);
return 0;
}
//
// Set the cursor to be the active cursor
// Specifying 0 will use the system default cursor
//
Bool Set(U32 id)
{
ASSERT(sysInit);
// If id is 0 use the default cursor
if (id == 0)
{
id = standardCrs[0];
}
Base *crs = cursors.Find(id);
if (crs != NULL)
{
if (crs != current)
{
// Shutdown current
if (current)
{
current->Notify(Base::CN_DEACTIVATE);
}
// Start the cursor
current = crs;
current->Notify(Base::CN_ACTIVATE);
}
return (TRUE);
}
else
{
return (FALSE);
}
}
void Print(int x) { // just for trace/debug the program
int y = x;
if (this) {
while (x > 0) {
cout << " ";
x--;
}
cout << stateName[data] << endl;
if (left) {
left->Print(y+1);
}
if (right) {
right->Print(y);
}
}
};
int main(int argn, char *argc[])
{
int n = 1000;
unsigned int t = time(0);
int value;
if (argn > 1)
n = atoi(argc[1]);
if (argn > 2)
t = atoi(argc[2]);
srand(t);
cout << "writeBinTree " << n << " " << t << endl;
BinTree<int> tree;
BinTree<int>::Node *node;
int i;
for (i = 0; i < 30; i++)
{
do
{
value = (int) (500.0*rand()/(RAND_MAX+1.0));
node = tree.search(value);
} while (node not_eq NULL);
node = new BinTree<int>::Node (value);
tree.insert(node);
}
preOrderRec(tree.getRoot(), print_ex);
inOrderRec(tree.getRoot(), print_tex);
destroyRec(tree.getRoot());
for (i = 0; i < n; i++)
{
do
{
value = (int) (n*10.0*rand()/(RAND_MAX+1.0));
node = tree.search(value);
} while (node not_eq NULL);
node = new BinTree<int>::Node (value);
tree.insert(node);
}
preOrderRec(tree.getRoot(), print_key);
destroyRec(tree.getRoot());
}
int main() {
BinTree<string, int> yankees;
yankees.Append("Ichiro", 31);
yankees.Append("Jeter", 2);
yankees.Append("Cano", 24);
yankees.Append("Teixeira", 25);
yankees.Append("Granderson", 14);
yankees.Append("Nix", 17);
yankees.Append("Chavez", 12);
yankees.Append("A.Jones", 22);
yankees.Append("Martin", 55);
yankees.Dump();
return 0;
}
int main(int argc, char** argv)
{
srand(time(0));
BinTree tree;
cout << "Inserting 6 nodes with random values: " << endl;
tree.insertNode(rand()%100+1);
tree.insertNode(rand()%100+1);
tree.insertNode(rand()%100+1);
tree.insertNode(rand()%100+1);
tree.insertNode(rand()%100+1);
tree.insertNode(rand()%100+1);
int x = rand()%100+1;
tree.insertNode(x);
cout << endl;
cout << "Values displayed using in-order traversal: " << endl;
tree.displayInOrder();
cout << endl;
cout << "Values displayed using pre-order traversal: " << endl;
tree.displayPreOrder();
cout << endl;
cout << "Values displayed using post-order traversal: " << endl;
tree.displayPostOrder();
cout << endl;
cout << "Deleting a node: value " << x << " removed." << endl;
tree.remove(x);
cout << "Values displayed using in-order traversal after deleting node: " << endl;
tree.displayInOrder();
cout << endl;
return 0;
}
void testAssignment()
{
BinTree<int> t;
t.add(10,"").add(12,"L").add(14,"R").add(15,"LR");
simplePrint(t);
BinTree<int> t1;
t1 = t;
assert (t1.member(10) &&
t1.member (12) &&
t1.member (14) &&
t1.member (15));
}
bool FileIntersect::processUnsortedFiles()
{
const QuickString &databaseFilename = _context->getDatabaseFileName();
BinTree *binTree = new BinTree(_context->getDatabaseFileIdx(), _context);
FileRecordMgr *queryFRM = new FileRecordMgr(_context->getQueryFileIdx(), _context);
if (!queryFRM->open()) {
return false;
}
if (!binTree->loadDB()) {
fprintf(stderr, "Error: Unable to load database file %s.\n", databaseFilename.c_str());
delete binTree;
exit(1);
}
_context->determineOutputType();
_recordOutputMgr->init(_context);
while (!queryFRM->eof()) {
Record *queryRecord = queryFRM->allocateAndGetNextRecord();
if (queryRecord == NULL) {
continue;
}
RecordKeyList hitSet(queryRecord);
binTree->getHits(queryRecord, hitSet);
if (_context->getObeySplits()) {
RecordKeyList keySet(hitSet.getKey());
RecordKeyList resultSet;
_blockMgr->findBlockedOverlaps(keySet, hitSet, resultSet);
processHits(resultSet);
} else {
processHits(hitSet);
}
queryFRM->deleteRecord(queryRecord);
}
queryFRM->close();
//clean up.
delete queryFRM;
delete binTree;
return true;
}
///////////////////////////////////////////////////////////////////////////////
//
// Quake::CmdHandler
//
void CmdHandler(U32 pathCrc)
{
switch (pathCrc)
{
case 0x3860F45E: // "quake.active"
if (*active)
{
effect->StopByEffect();
effect->Play2D(Sound::Digital::DEFAULT_VOLUME, Sound::Digital::NO_OWNER, F32_MAX, 0);
soundoff = FALSE;
quakeAnim.SetFrame(0);
}
else
{
effect->StopByEffect();
soundoff = TRUE;
}
break;
case 0x030664FD: // "quake.type"
{
Type * t = typeList.Find( Crc::CalcStr( *typeVar));
if (t)
{
SetCurrent( t);
}
break;
}
case 0x44327F38: // "quake.listtypes"
{
char *s = NULL;
Console::GetArgString(1, s);
U32 len = 0;
if (s)
{
len = strlen(s);
}
// Registered quake types
CON_DIAG(("[Quake Types]"))
BinTree<Type>::Iterator i(&typeList);
for (!i; *i; i++)
{
if (!s || !Utils::Strnicmp( (*i)->name.str, s, len))
{
Console::Message("%s", (*i)->name.str);
}
}
break;
}
//
} // switch( pathCrc)
}
int main()
{
char* str = "123##4##56###";
BinTree<char> mytree;
// char* VLR = "123456";
// char* LVR = "324165";
// int len = strlen(VLR);
mytree.CreatTree(str);
mytree.zigzagLevelOrder();
// mytree.RecPreOrder();
// mytree.RecInOrder();
// mytree.RecPostOrder();
// mytree.LevelOrder();
// mytree.PreOrder();
// mytree.InOrder();
// mytree.PostOrder();
// mytree._CreatTree(VLR, LVR,len);
system("pause");
return 0;
}
int main()
{
//Binary tree traversal
BinTree tree;
Node h = {8, NULL, NULL};
Node g = {7, NULL, &h};
Node f = {6, NULL, NULL};
Node e = {5, &f, &g};
Node d = {4, NULL, &e};
Node c = {3, NULL, NULL};
Node b = {2, &d, NULL};
Node a = {1, &b, &c};
tree.SetRoot(&a);
cout << "Preorder traverse" << endl;
tree.PreorderTraverse();
cout << "Inorder traverse" << endl;
tree.InorderTraverse();
cout << "Postorder traverse" << endl;
tree.PostorderTraverse();
}
void SearchTree<Key,Data>::voegtoe(BinTree<Key,Data>& node, const Key& sl,const Data& data){
BinTree<Key,Data> *kind;
if (sl < node->sl)
kind=&(node->left);
else
kind=&(node->right);
if (*kind == 0){
(*kind) = move((unique_ptr<BinNode<Key,Data>>) new BinNode<Key,Data>(sl,data));
(*kind)->parent = node.get();
}
else
voegtoe(*kind, sl,data);
}
//
// Find a cursor by name
//
U32 FindByName(const char *name)
{
U32 id = Crc::CalcStr(name);
// Ensure the cursor exists
if (cursors.Find(id))
{
return (id);
}
else
{
LOG_ERR(("Cursor [%s] not found", name));
return (0);
}
}
//------------------------------------------------ setCustomer()
void Borrow::setCustomer(istream& in, BinTree& cust) {
int customerID = 0;
in >> customerID;
Customer target(customerID); // empty instance with only id
Generic* customerInStore = NULL;
cust.retrieve(target, customerInStore);
// pointer is now modified to point to the customer in our store
if(customerInStore != NULL) { // if found
// down-cast and store reference
customer = dynamic_cast<Customer*>(customerInStore);
} else {
customer = NULL;
}
// target goes out of scope and gets destroyed
}
void buildTree(BinTree& T, ifstream& infile) {
string s;
for (;;) {
infile >> s;
cout << s << ' ';
if (s == "$$") break; // at end of one line
if (infile.eof()) break; // no more lines of data
NodeData* ptr = new NodeData(s); // NodeData constructor takes string
// would do a setData if there were more than a string
bool success = T.insert(ptr);
if (!success)
delete ptr; // duplicate case, not inserted
}
}
//
// Delete all cursors
//
void DeleteAll()
{
ASSERT(sysInit);
// Unset the current cursor
current = NULL;
// Clear standard cursors
for (int i = 0; i < MAX_CURSORS; i++)
{
standardCrs[i] = 0;
}
// Delete all cursors
cursors.DisposeAll();
}
