int main(){
BST bst;
bst.insert(1);
bst.insert(3);
bst.insert(2);
for (BST::iterator i = bst.begin(); i != bst.end(); ++i){
cout << *i << endl;
}
}
int main(){
BST<int> bst;
bst.add(2);
bst.add(1);
bst.add(3);
bst.add(13);
bst.add(31);
for (BST<int>::iterator i = bst.begin(); i != bst.end(); ++i){
cout << *i << endl;
}
}
void BTSort(arrayItems D[])
{
BST<arrayItems> sortBin;
// insert data to BST
for (int i = 0; i < NUMITEMS; i++)
sortBin.insert(D[i]);
int count = 0;
BSTiterator<arrayItems> it;
// copy back to the array
for (BSTiterator<arrayItems> it = sortBin.begin(); it != sortBin.end(); it++)
{
D[count] = * it;
count++;
}
}
/**
* A simple test driver for the BST class template.
* P1 CSE 100 2012
* Author: P. Kube (c) 2012
*/
int main() {
/* Create an STL vector of some ints */
vector<int> v;
v.push_back(3);
v.push_back(4);
v.push_back(1);
v.push_back(100);
v.push_back(-33);
v.push_back(2);
v.push_back(10);
v.push_back(-3);
/* Create an instance of BST holding int */
BST<int> b;
/* Insert a few data items. */
vector<int>::iterator vit = v.begin();
vector<int>::iterator ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return true
if(! b.insert(*vit) ) {
cout << "Incorrect return value when inserting " << *vit << endl;
return -1;
}
}
vit = v.begin();
for(; vit != ven; ++vit) {
// all these inserts are duplicates, so should return false
if( b.insert(*vit) ) {
cout << "Incorrect return value when re-inserting " << *vit << endl;
return -1;
}
}
/* Test size. */
cout << "Size is: " << b.size() << endl;
if(b.size() != v.size()) {
cout << "... which is incorrect." << endl;
return -1;
}
/* Test find return value. */
vit = v.begin();
for(; vit != ven; ++vit) {
if(*(b.find(*vit)) != *vit) {
cout << "Incorrect return value when finding " << *vit << endl;
return -1;
}
}
/* Sort the vector, to compare with inorder iteration on the BST */
sort(v.begin(),v.end());
/* Test BST iterator; should iterate inorder */
cout << "traversal using iterator:" << endl;
vit = v.begin();
BST<int>::iterator en = b.end();
BST<int>::iterator it = b.begin();
for(; vit != ven; ++vit) {
cout << *it << endl;
if(*it != *vit) {
cout << *it << "," << *vit << ": Incorrect inorder iteration of BST." << endl;
return -1;
}
++it;
}
cout << "OK." << endl;
}
/**
* A simple test driver for the BST class template.
* P1 CSE 100 2010
* Author: P. Kube (c) 2010
*/
int main() {
/* Create an STL vector of some ints */
vector<int> v;
map<int, bool> m;
for (int i = 0; i < 50; ++i) {
int n = rand() % 1000;
if (!m[n]) {
m[n] = true;
v.push_back(n);
}
}
v.erase(unique(v.begin(), v.end()), v.end());
std::cout << "v is size: " << v.size() << std::endl;
for (size_t i = 0; i < v.size(); ++i) {
//std::cout << v[i] << std::endl;
}
/* Create an instance of BST holding int */
BST<int> b;
/* Insert a few data items. */
vector<int>::iterator vit = v.begin();
vector<int>::iterator ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return true
if(! b.insert(*vit) ) {
cout << "Incorrect return value when inserting " << *vit << endl;
return -1;
}
}
for(; vit != ven; ++vit) {
// all these inserts are duplicates, so should return false
if( b.insert(*vit) ) {
cout << "Incorrect return value when re-inserting " << *vit << endl;
return -1;
}
}
/* Test size. */
cout << "Size is: " << b.size() << endl;
if(b.size() != v.size()) {
cout << "... which is incorrect." << endl;
return -1;
}
/* Test find return value. */
vit = v.begin();
for(; vit != ven; ++vit) {
if(*(b.find(*vit)) != *vit) {
cout << "Incorrect return value when finding " << *vit << endl;
return -1;
}
}
/* Sort the vector, to compare with inorder iteration on the BST */
sort(v.begin(),v.end());
/* Test BST iterator; should iterate inorder */
cout << "traversal using iterator:" << endl;
vit = v.begin();
BST<int>::iterator en = b.end();
BST<int>::iterator it = b.begin();
for(; it != en; ++it) {
cout << *it << endl;
if(*it != *vit) {
cout << *it << "," << *vit << ": Incorrect inorder iteration of BST." << endl;
return -1;
}
++vit;
}
}
/**
* A simple test driver for the BST class template.
* P1 CSE 100 2013
* Author: P. Kube (c) 2013
*/
int main() {
/* Create an STL vector of some ints */
vector<int> v;
v.push_back(3);
v.push_back(4);
v.push_back(1);
v.push_back(33);
v.push_back(66);
v.push_back(144);
v.push_back(1984);
v.push_back(-92393);
v.push_back(46);
v.push_back(22);
v.push_back(0);
v.push_back(123445);
v.push_back(100);
v.push_back(-33);
/*
vector<string> v;
v.push_back("hi");
v.push_back("hi no");
v.push_back("hi yes");
v.push_back("hi you");
v.push_back("hi fly");
v.push_back("hi w");
*/
/* Create an instance of BST holding int */
BST<int> b;
// BST<string> b;
/* Insert a few data items. */
vector<int>::iterator vit = v.begin();
vector<int>::iterator ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<BST<int>::iterator,bool> pr = b.insert(*vit);
// if(! pr.second ) {
// cout << "Incorrect bool return value when inserting " << *vit << endl;
// return -1;
// }
if(*(pr.first) != *vit) {
cout << "Incorrect iterator return value when inserting " << *vit << endl;
return -1;
}
}
/* Test size. */
cout << "" << endl;
cout << "Size is: " << b.size() << endl;
cout << "" << endl;
if(b.size() != 14) {
cout << "... which is incorrect." << endl;
return -1;
}
/* Test find return value. */
vit = v.begin();
for(; vit != ven; ++vit) {
if(*(b.find(*vit)) != *vit) {
cout << "Incorrect return value when finding " << *vit << endl;
return -1;
}
}
/* This is for testing find on something not in the BST
* Causes a seg fault so it is taken out
BST<int>::iterator it3 = b.find(5);;
cout << *it3 << endl;
*/
/* Sort the vector, to compare with inorder iteration on the BST */
sort(v.begin(),v.end());
/* Test BST iterator; should iterate inorder */
cout << "traversal using iterator:" << endl;
cout << "" << endl;
vit = v.begin();
BST<int>::iterator en = b.end();
BST<int>::iterator it = b.begin();
for(; vit != ven; ++vit) {
cout << *it << endl;
if(*it != *vit) {
cout << *it << "," << *vit << ": Incorrect inorder iteration of BST." << endl;
return -1;
}
++it;
}
cout << "" << endl;
cout << "OK, order is correct" << endl;
cout << "" << endl;
/* Testing == and !=*/
cout << "Testing equals and not equals:" << endl;
cout << "" << endl;
BST<int>::iterator test1 = b.begin();
BST<int>::iterator test2 = b.begin();
if(*test1 != *test2) {
cout << *test1 << " and " << *test2 << ": Should be equal." << endl;
return -1;
}
cout << "Correct! " << *test1 << " and " << *test2 << ": Are equal." << endl;
cout << "" << endl;
++test1;
if(*test1 == *test2) {
cout << *test1 << " and " << *test2 << ": Should NOT be equal." << endl;
return -1;
}
cout << "Correct! " <<*test1 << " and " << *test2 << ": Are NOT equal." << endl;
cout << "" << endl;
cout << "== and != tests passed!" << endl;
cout << "" << endl;
cout << "Testing find...Printing all with find" << endl;
cout << "" << endl;
BST<int>::iterator test100 = b.find(3);
cout << *test100 << endl;
test100 = b.find(4);
cout << *test100 << endl;
test100 = b.find(1);
cout << *test100 << endl;
test100 = b.find(33);
cout << *test100 << endl;
test100 = b.find(66);
cout << *test100 << endl;
test100 = b.find(144);
cout << *test100 << endl;
test100 = b.find(1984);
cout << *test100 << endl;
test100 = b.find(-92393);
cout << *test100 << endl;
test100 = b.find(46);
cout << *test100 << endl;
test100 = b.find(22);
cout << *test100 << endl;
test100 = b.find(0);
cout << *test100 << endl;
test100 = b.find(123445);
cout << *test100 << endl;
test100 = b.find(100);
cout << *test100 << endl;
test100 = b.find(-33);
cout << *test100 << endl;
test100 = b.find(666);
BST<int>::iterator test101 = b.end();
BST<int>::iterator test102 = b.begin();
if(test100 == test101) {
cout << "666 returns null" << endl;
cout << "" << endl;
}
if(test100 != test102) {
cout << "Passes another check for !=" << endl;
cout << "" << endl;
}
cout << "Testing Clear..." << endl;
cout << "" << endl;
b.clear();
cout << "Clear Ran, Now Testing Size." << endl;
cout << "" << endl;
/* Test size. */
cout << "Size is: " << b.size() << endl;
cout << "" << endl;
if(b.size() != 0) {
cout << "BST WAS NOT CLEARED!!!!" << endl;
return -1;
}
cout << "Correct! YAY! Super Great!" << endl;
cout << "" << endl;
/* Test BST iterator; should iterate inorder */
cout << "This should cause a seg fault if BST is empty:" << endl;
cout << "" << endl;
BST<int>::iterator it2 = b.begin();
cout << *it2 << endl;
}
/**
* A simple test driver for the BST class template.
* P1 CSE 100 2013
* Author: P. Kube (c) 2013
*/
int main() {
/* Create an STL vector of some ints */
vector<int> v;
v.push_back(3);
v.push_back(4);
v.push_back(1);
v.push_back(100);
v.push_back(-33);
/* Create an instance of BST holding int */
BST<int> b;
/* Insert a few data items. */
vector<int>::iterator vit = v.begin();
vector<int>::iterator ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<BST<int>::iterator,bool> pr = b.insert(*vit);
cout << "vit = " << *vit << endl;
if(! pr.second ) {
cout << "Incorrect bool return value when inserting " << *vit << endl;
return -1;
}
if(*(pr.first) != *vit) {
cout << "Incorrect iterator return value when inserting " << *vit << endl;
return -1;
}
}
/* Test size. */
cout << "Size is: " << b.size() << endl;
if(b.size() != v.size()) {
cout<< "bsize is" << b.size() << endl;
cout<< "vsize is" << v.size() << endl;
cout << "... which is incorrect." << endl;
return -1;
}
cout<<"simple test" << endl;
for(BST<int>::iterator it = b.begin(); it != b.end(); ++it){
cout<<*it<< endl;
}
/* Test find return value. */
vit = v.begin();
for(; vit != ven; ++vit) {
if(*(b.find(*vit)) != *vit) {
cout << "Incorrect return value when finding " << *vit << endl;
return -1;
}
}
/* Sort the vector, to compare with inorder iteration on the BST */
sort(v.begin(),v.end());
/* Test BST iterator; should iterate inorder */
cout << "traversal using iterator:" << endl;
vit = v.begin();
BST<int>::iterator en = b.end();
BST<int>::iterator it = b.begin();
for(; vit != ven; ++vit) {
if(! (it != en) ) {
cout << *it << "," << *vit << ": Early termination of BST iteration." << endl;
return -1;
}
cout << *it << endl;
if(*it != *vit) {
cout << *it << "," << *vit << ": Incorrect inorder iteration of BST." << endl;
return -1;
}
++it;
}
cout << "OK." << endl;
/* Testing clear and checking clear size afterwards*/
BST<int> c;
vit = v.begin();
ven = v.end();
for(vit = v.begin(); vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<BST<int>::iterator,bool> pr = c.insert(*vit);
}
c.clear();
cout<< "clear size is" << c.size() << endl;
if(c.size() != 0){
cout << "fail" << endl;
return -1;
}
/* Testing BST destructor */
BST<int>* d = new BST<int>();
d->insert(3);
delete d;
/*Test Clear then add and size after */
BST<int> e;
vit = v.begin();
ven = v.end();
for(vit = v.begin(); vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<BST<int>::iterator,bool> pr = e.insert(*vit);
}
e.clear();
e.insert(5);
cout<< "e size is " << e.size() << endl;
/* Test insert of same item */
BST<int> f;
vit = v.begin();
ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<BST<int>::iterator,bool> pk = f.insert(*vit);
}
std::pair<BST<int>::iterator,bool> pi = f.insert(3);
if(pi.second){
cout << "you f****d up" << endl;
cout << "value is " << *(pi.first) << endl;
return -1;
}
/* Clear an empty tree */
BST<int> q;
q.clear();
}
/**
* A simple test driver for the BST class template.
* P1 CSE 100 2013
* Author: P. Kube (c) 2013
*/
int main() {
/* Create an STL vector of some ints */
vector<int> v;
vector<int> random;
v.push_back(50);
v.push_back(60);
v.push_back(30);
v.push_back(33);
v.push_back(38);
v.push_back(35);
v.push_back(37);
v.push_back(20);
// v.push_back(15);
// Overriding for more extensive tests */
/*
srand(time(NULL));
for (int i = 0; i < 10000; i++ )
{
int r = rand() % 10000;
bool dupe = false;
vector<int>::iterator ranit = random.begin();
vector<int>::iterator ranen = random.end();
for(; ranit != ranen; ++ranit)
{
if (*ranit == r)
{
//cout << "dupe" << endl;
dupe = true;
// return -1;
}
}
if (!dupe)
{
cout << r << endl;
random.push_back(r);
v.push_back(r);
}
}
*/
/* Create an instance of BST holding int */
BST<int> b;
/* Insert a few data items. */
vector<int>::iterator vit = v.begin();
vector<int>::iterator ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<BST<int>::iterator,bool> pr = b.insert(*vit);
if(! pr.second ) {
cout << "Incorrect bool return value when inserting " << *vit << endl;
return -1;
}
if(*(pr.first) != *vit) {
cout << "Incorrect iterator return value when inserting " << *vit << endl;
return -1;
}
}
/* Test inserting repeated values - expected false result */
/*
vector<int> z;
z.push_back(1);
z.push_back(3);
vector<int>::iterator bit = z.begin();
vector<int>::iterator ben = z.end();
for(; bit !=ben; ++bit) {
std::pair<BST<int>::iterator,bool> pr = b.insert(*bit);
if( pr.second ) {
cout << "Incorrect bool return value when inserting " << *bit << endl;
return -1;
}
if(*(pr.first) != *bit) {
cout << "Incorrect iterator return value when inserting " << *bit << endl;
return -1;
}
}
// Make sure size hasn't changed for failed inputs.
cout << "Size is: " << b.size() << endl;
if(b.size() == z.size()) {
cout << "... which is incorrect." << endl;
return -1;
}
*/
/* Test size. */
cout << "Size is: " << b.size() << endl;
if(b.size() != v.size()) {
cout << "... which is incorrect." << endl;
return -1;
}
/* Test find return value. */
vit = v.begin();
for(; vit != ven; ++vit) {
if(*(b.find(*vit)) != *vit) {
cout << "Incorrect return value when finding " << *vit << endl;
return -1;
}
}
/* Sort the vector, to compare with inorder iteration on the BST */
sort(v.begin(),v.end());
/* Test BST iterator; should iterate inorder */
cout << "traversal using iterator:" << endl;
vit = v.begin();
BST<int>::iterator en = b.end();
BST<int>::iterator it = b.begin();
for(; vit != ven; ++vit) {
if(! (it != en) ) {
cout << *it << "," << *vit << ": Early termination of BST iteration." << endl;
return -1;
}
cout << *it << endl;
if(*it != *vit) {
cout << *it << "," << *vit << ": Incorrect inorder iteration of BST." << endl;
return -1;
}
++it;
}
cout << "OK." << endl;
}
/**
* A simple test driver for the BST class template.
* P1 CSE 100 2013
* Author: P. Kube (c) 2013
*/
int main() {
/* Create an STL vector of some ints */
vector<int> v;
/*
v.push_back(3);
v.push_back(4);
v.push_back(1);
v.push_back(100);
v.push_back(-33);
v.push_back(-20);
v.push_back(6);
v.push_back(0);
v.push_back(-1);
v.push_back(-2);
v.push_back(-3);
v.push_back(-4);
*/
/* Create an instance of BST holding int */
BST<int> b;
/* Insert a few data items. */
vector<int>::iterator vit = v.begin();
vector<int>::iterator ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<BST<int>::iterator,bool> pr = b.insert(*vit);
if(! pr.second ) {
cout << "Incorrect bool return value when inserting " << *vit << endl;
return -1;
}
if(*(pr.first) != *vit) {
cout << "Incorrect iterator return value when inserting " << *vit << endl;
return -1;
}
}
/* Test size. */
cout << "Size is: " << b.size() << endl;
if(b.size() != v.size()) {
cout << "... which is incorrect." << endl;
return -1;
}
/* Test find return value. */
vit = v.begin();
for(; vit != ven; ++vit) {
if(*(b.find(*vit)) != *vit) {
cout << "Incorrect return value when finding " << *vit << endl;
return -1;
}
}
/* Sort the vector, to compare with inorder iteration on the BST */
sort(v.begin(),v.end());
/* Test BST iterator; should iterate inorder */
cout << "traversal using iterator:" << endl;
vit = v.begin();
BST<int>::iterator en = b.end();
BST<int>::iterator it = b.begin();
for(; vit < ven; ++vit) {
if(! (it != en) ) {
cout << *it << "," << *vit << ": Early termination of BST iteration." << endl;
return -1;
}
cout << *it << endl;
if(*it != *vit) {
cout << *it << "," << *vit << ": Incorrect inorder iteration of BST." << endl;
return -1;
}
++it;
}
/** Added a basic clear tests that checks for correct size after delete */
cout << "OK." << endl;
b.clear();
cout << ((b.size() == 0)
? "PASS: clear() size of tree: "
: "FAIL: clear() Size of tree: ") << b.size() << endl;
/** ================================ Added test Cases =====================*/
/* Test fixtures */
vector<int> v2;
srand(unsigned(time(NULL)));
BST<int> b2;
BST<int>* treeDestructorTest = new BST<int>();
unsigned int numInspected = 0;
unsigned int sizeOfInput = 0;
for(int i = 1000; i >= -1000; i--){
v2.push_back(i);
sizeOfInput++;
}
/* randomize the ordering of -1000 - 1000 before inserting
* so we don't just test a linked list
*/
std::random_shuffle(v2.begin(), v2.end());
vector<int>::iterator vit2 = v2.begin();
vector<int>::iterator ven2 = v2.end();
/* insert all the items in the randomized vector into the bst
* and check the boolean return
*/
while( vit2 != ven2 ){
if( !(b2.insert(*vit2)).second ){
cout << "incorrect boolean return value of insert for: "<< *vit2 <<endl;
return -1;
}
++vit2;
}
cout << "PASS: insert() unique value, boolean return. " << endl;
/* try to insert the values again. checking for correct return
* boolean on duplicate insertion.
*/
for( vit2 = v2.begin(); vit2 != ven2; ++vit2 ){
if( (b2.insert(*vit2)).second ){
cout << "incorrect boolean return value of duplicate "
<< "insert for: "<< *vit2 << endl;
return -1;
}
}
cout << "PASS: insert() duplicate value, boolean return. " << endl;
/** sort the vector for inorder traversal */
sort(v2.begin(), v2.end());
vector<int>::iterator vit3 = v2.begin();
vector<int>::iterator ven3 = v2.end();
BST<int>::iterator front = b2.begin();
BST<int>::iterator back = b2.end();
/* check that each returned element is the correct successor */
for( ; vit3 != ven3; ++front, ++vit3 ){
if( *front != *vit3 ){
cout << "FAIL: inorder traversal failed on : " << *front
<< " " << *vit3 << endl;
return -1;
}
++numInspected;
}
cout << "PASS: iterator correct element ordering in traversal. " << endl;
/* check we traversed all the elements in the tree */
if( numInspected != sizeOfInput ){
cout << "FAIL: incomplete tree traversal. Read " << numInspected
<< " of " << sizeOfInput << " elements." << endl;
return -1;
}else{
cout << "PASS: iterator number of elements read Expected: "
<< sizeOfInput << " Result: "
<< numInspected << endl;
}
/* randomize the vector again */
std::random_shuffle(v2.begin(), v2.end());
/* test find on all the items in the vector & bst */
for(vit3 = v2.begin(); vit3 != ven3; ++vit3){
if( *(b2.find(*vit3)) != *vit3 ){
cout << "FAIL: find return value did not match: " << *vit3 << endl;
return -1;
}
}
cout << "PASS: find() returned all correct values." << endl;
cout << ( (b2.size() == sizeOfInput)
? "PASS: size() returned expected tree size. "
: "FAIL: size() returned non-matching tree size. " ) << endl;
cout << ( (b2.empty() == false)
? "PASS: empty() returned false when not empty. "
: "FAIL: empty() returned true when not empty. " ) << endl;
b2.clear();
cout << ( (b2.empty() == true)
? "PASS: empty() returned true when empty. "
: "FAIL: empty() returned false when empty. " ) << endl;
/** Test for memory leaks when allocating a tree on the heap
* using valgrind will tell you if this passes or not
*/
treeDestructorTest->insert(1);
treeDestructorTest->insert(2);
treeDestructorTest->insert(0);
treeDestructorTest->clear();
treeDestructorTest->insert(3);
treeDestructorTest->insert(5);
treeDestructorTest->insert(0);
delete treeDestructorTest;
cout << "PASS: No errors when calling destructor after clear(). i" << endl;
cout << " Run valgrind for memory leak analysis. " << endl;
/*****************************START Testing for RST***********************/
RST<int> r;
/* Insert a few data items. */
vit = v.begin();
//vector<int>::iterator ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<RST<int>::iterator,bool> pr = r.insert(*vit);
if(! pr.second ) {
cout << "Incorrect bool return value when inserting into RST " << *vit << endl;
return -1;
}
if(*(pr.first) != *vit) {
cout << "Incorrect iterator return value when inserting into RST " << *vit << endl;
return -1;
}
}
//PASS insert rst test
cout << "PASS Insert into RST" << endl;
/* Test size. */
cout << "Size is: " << r.size() << endl;
if(r.size() != v.size()) {
cout << "... which is incorrect." << endl;
return -1;
}
/* Test find return value. */
vit = v.begin();
for(; vit != ven; ++vit) {
if(*(r.find(*vit)) != *vit) {
cout << "Incorrect return value when finding " << *vit << endl;
return -1;
}
}
/* Sort the vector, to compare with inorder iteration on the BST */
sort(v.begin(),v.end());
/* Test BST iterator; should iterate inorder */
cout << "traversal using iterator:" << endl;
vit = v.begin();
//BST<int>::iterator en = r.end();
//BST<int>::iterator it = r.begin();
for(; vit < ven; ++vit) {
if(! (it != en) ) {
cout << *it << "," << *vit << ": Early termination of BST iteration." << endl;
return -1;
}
cout << *it << endl;
if(*it != *vit) {
cout << *it << "," << *vit << ": Incorrect inorder iteration of BST." << endl;
return -1;
}
++it;
}
/** Added a basic clear tests that checks for correct size after delete */
cout << "OK." << endl;
r.clear();
cout << ((r.size() == 0)
? "PASS: clear() size of tree: "
: "FAIL: clear() Size of tree: ") << r.size() << endl;
//END OF FILE
}
/**
* A simple test driver for the BST class template.
* P1 CSE 100 2013
* Author: P. Kube (c) 2013
*/
int main() {
/* Create an STL vector of some ints */
vector<int> v;
v.push_back(3);
v.push_back(4);
v.push_back(1);
v.push_back(100);
v.push_back(-33);
/* Create an instance of BST holding int */
BST<int> b;
/* Insert a few data items. */
vector<int>::iterator vit = v.begin();
vector<int>::iterator ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<BST<int>::iterator,bool> pr = b.insert(*vit);
if(! pr.second ) {
cout << "Incorrect bool return value when inserting " << *vit << endl;
return -1;
}
if(*(pr.first) != *vit) {
cout << "Incorrect iterator return value when inserting " << *vit << endl;
return -1;
}
}
/* Test size. */
cout << "Size is: " << b.size() << endl;
if(b.size() != v.size()) {
cout << "... which is incorrect." << endl;
return -1;
}
/* Test find return value. */
vit = v.begin();
for(; vit != ven; ++vit) {
if(*(b.find(*vit)) != *vit) {
cout << "Incorrect return value when finding " << *vit << endl;
return -1;
}
}
/* Sort the vector, to compare with inorder iteration on the BST */
sort(v.begin(),v.end());
/* Test BST iterator; should iterate inorder */
cout << "traversal using iterator:" << endl;
vit = v.begin();
BST<int>::iterator en = b.end();
BST<int>::iterator it = b.begin();
for(; vit != ven; ++vit) {
if(! (it != en) ) {
cout << *it << "," << *vit << ": Early termination of BST iteration." << endl;
return -1;
}
cout << *it << endl;
if(*it != *vit) {
cout << *it << "," << *vit << ": Incorrect inorder iteration of BST." << endl;
return -1;
}
++it;
}
cout << "OK." << endl;
}
/**
* A simple partial test driver for the RST class template.
* P2 CSE 100
* Author: P. Kube (c) 2010, 2013
*/
int main(int argc, char** argv) {
int N = 1000;
if(argc > 1) N = atoi(argv[1]);
// a good RST implementation should need no more than this number
// of key comparisons when inserting N keys
double maxcompsperkey = (log(N) * 2.5);
cout << "Log(n) is: " << log(N) << endl;
/* Create an STL vector of some countints, in sorted order */
vector<countint> v;
for(int i=0; i<N; i++) {
// v.push_back(i);
v.push_back(i);
}
/* Create an empty instance of RST holding countint */
BST<countint>* r = new RST<countint>();
/* Clear the comparison counter */
countint::clearcount();
/* Insert the data items, in order */
cout << "Inserting " << N << " sorted keys in initially empty RST...";
vector<countint>::iterator vit = v.begin();
vector<countint>::iterator ven = v.end();
for(; vit != ven; ++vit) {
// all these inserts are unique, so should return a std::pair
// with second part true
std::pair<BST<countint>::iterator,bool> pr = r->insert(*vit);
if(! pr.second ) {
cout << "Incorrect bool return value when inserting " << *vit << endl;
return -1;
}
// countint rc = *(pr.first);
// countint bc = *vit;
// if(rc < bc || bc < rc) {
// cout << "Incorrect iterator return value when inserting " << *vit << endl;
// return -1;
// }
}
cout << " done." << endl;
// r->inorder();
//r->print_structure();
/* How many comparisons did it take to do the inserts, avg per key? */
double compsperkey = countint::getcount() / (double) N;
cout << "That took " << compsperkey << " average comparisons per key, " << endl;
cout << "Max compare key is: " << maxcompsperkey << endl;
if(compsperkey <= maxcompsperkey) cout << "OK. " << endl;
else if (compsperkey <= maxcompsperkey * 2) cout << "could be better... " << endl;
else {
cout << "way too many!" << endl;
return -1;
}
/* Test iterator; should iterate the entire tree inorder */
cout << "Checking traversal using iterator...";
vit = v.begin();
BST<countint>::iterator en = r->end();
BST<countint>::iterator it = r->begin();
int i = 0;
for(; it != en; ++it) {
// cout << *it << endl;
countint rc = *it;
countint bc = *vit;
if(rc < bc || bc < rc) {
cout << endl << "Incorrect inorder iteration of RST." << endl;
return -1;
}
++i;
++vit;
}
if(i!=N) {
cout << endl << "Early termination during inorder iteration of RST." << endl;
return -1;
}
cout << " OK." << endl;
return 0;
}
