void delete_2_RBTree(){ RBTree rbt; std::vector<UInt32> array(3); array[0] = 2; array[1] = 1; array[2] = 3; Test_Sorted_Order_Key tk0(array, 2); BOOST_REQUIRE(rbt.insert(tk0, 0) == true); Test_Sorted_Order_Key tk1(array, 1); BOOST_REQUIRE(rbt.insert(tk1, 1) == true); Test_Sorted_Order_Key tk2(array, 3); BOOST_REQUIRE(rbt.insert(tk1, 2) == true); UInt32 searched; BOOST_REQUIRE(rbt.remove(tk0) == true); BOOST_REQUIRE(rbt.find(tk0, searched) == false); BOOST_REQUIRE(rbt.remove(tk1) == true); BOOST_REQUIRE(rbt.find(tk1, searched) == false); BOOST_REQUIRE(rbt.remove(tk2) == true); BOOST_REQUIRE(rbt.find(tk2, searched) == false); }
int main() { CountTime count_time; RBTree<int> rbt; for (unsigned i = 0; i < 1000000; ++i) rbt.insert(i); rbt.inOrder(); // rbt.insert(31); // rbt.insert(25); // rbt.insert(3); // rbt.insert(10); // rbt.insert(33); // rbt.insert(7); // rbt.insert(131); // rbt.insert(321); // rbt.insert(32); // rbt.insert(1); // rbt.insert(41); // rbt.insert(11); // rbt.insert(333); // rbt.insert(-23); // rbt.insert(9); // rbt.insert(32); // rbt.inOrder(); // rbt.deleteNode(33); // rbt.inOrder(); return 0; }
void multi_delete_RBTree(const std::vector<UInt32>& order_of_removal){ RBTree rbt; std::vector<UInt32> array(order_of_removal.size()); for(UInt32 i = 0; i < order_of_removal.size(); ++i){ array[i] = i; Test_Sorted_Order_Key tk(array, array[i]); BOOST_REQUIRE(rbt.insert(tk, i) == true); UInt32 searched; BOOST_REQUIRE(rbt.find(tk, searched) == true); BOOST_REQUIRE(searched == i); } for(UInt32 i = 0; i < order_of_removal.size(); ++i){ Test_Sorted_Order_Key tk( array, array[ order_of_removal[i] ] ); UInt32 searched; BOOST_REQUIRE(rbt.find(tk, searched) == true); BOOST_REQUIRE(rbt.remove(tk) == true); BOOST_REQUIRE(rbt.find(tk, searched) == false); } }
void multi_random_insert_Stepwise_Order_Check(){ RBTree rbt; std::vector<UInt32> array(10); array[0] = 4; array[1] = 43; array[2] = 23; array[3] = 6; array[4] = 57; array[5] = 5; array[6] = 8; array[7] = 1018; array[8] = 54; array[9] = 67; std::vector<UInt32> o_contents; for(UInt32 i = 0; i < 10; ++i){ Test_Sorted_Order_Key tk(array, array[i]); BOOST_REQUIRE(rbt.insert(tk, i) == true); rbt.traverse_inorder(o_contents); UInt32 sz = o_contents.size(); BOOST_REQUIRE(sz == ( i + 1 ) ); inorder_check_helper(o_contents, array); } }
void multi_insert_delete_RBTree(const std::vector<UInt32>& order_of_removal){ RBTree rbt; std::vector<UInt32> array(order_of_removal.size()); UInt32 sz = order_of_removal.size(); UInt32 filled = 0; while(filled < sz){ array[filled] = rand(); Test_Sorted_Order_Key tk( array, array[filled] ); if(rbt.insert(tk, filled) == false){ continue; } ++filled; } for(UInt32 i = 0; i < order_of_removal.size(); ++i){ Test_Sorted_Order_Key tk(array, array[ order_of_removal[i] ] ); UInt32 searched; BOOST_REQUIRE(rbt.find(tk, searched) == true); BOOST_REQUIRE(rbt.remove(tk) == true); BOOST_REQUIRE(rbt.find(tk, searched) == false); } }
void multi_random_insert_RBTree(){ RBTree rbt; std::vector<UInt32> array(10); array[0] = 4; array[1] = 43; array[2] = 23; array[3] = 6; array[4] = 57; array[5] = 5; array[6] = 8; array[7] = 1018; array[8] = 54; array[9] = 67; for(UInt32 i = 0; i < 10; ++i){ Test_Sorted_Order_Key tk(array, array[i]); BOOST_REQUIRE(rbt.insert(tk, i) == true); UInt32 searched; BOOST_REQUIRE(rbt.find(tk, searched) == true); BOOST_REQUIRE(searched == i); } for(UInt32 i = 0; i < 10; ++i){ Test_Sorted_Order_Key tk(array, array[i]); UInt32 searched; BOOST_REQUIRE(rbt.find(tk, searched) == true); BOOST_REQUIRE(searched == i); } }
void delete_rbt(){ RBTree<unsigned, double> rb; double v; srand(time(NULL)); for(unsigned i=0; i<1e4; ++i){ v = rand() * 1001 * 0.001f; rb.insert(i,v); } cout<< "height is " << rb.height() << endl; cout<< "# of left rotation = " << NUM_OF_LEFT_ROTATION << endl; cout<< "# of right rotation = " << NUM_OF_RIGHT_ROTATION <<endl; unsigned n; while( cin >> n ){ cout <<"key = " << n << "\tvalue = " << rb.get(n) << endl; if (n==1) break; } cout <<"size of BST is " << rb.size() << endl; cout <<"=====================ceiling floor======================" << endl; cout <<"floor of 4 is " << rb.floor(4) << endl; cout <<"floor of 9 is " << rb.floor(9) << endl; cout <<"ceiling of 4 is " << rb.ceiling(4) << endl; cout <<"ceiling of 9 is " << rb.ceiling(9) << endl; cout <<" is 2-3 tree ? " << rb.isLeftLeaning23tree() << endl; cout <<"is size consistent ? " << rb.isSizeConsistent() << endl; cout <<"Is balanced search tree ? " << rb.isBalancedSearchTree() << endl; cout <<"is rank consistent ? " << rb.isRankConsistent() << endl; }
//main int main(int argc, char **argv){ //int values[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; RBTree *rb = new RBTree; srand((unsigned)time(NULL)); for(int i = 0; i < 100; i++){ int n = rand() % 50000; rb->insert(n); } rb->run_test(); int num; do{ cout << "Enter an integer." << endl; cin >> num; rb->search(num); }while(num != 0); delete rb; return 0; }
void create_rbt(RBTree<int, string> &rb){ rb.insert(30, "thirty"); rb.insert(2, "two"); rb.insert(15, "fifteen"); rb.insert(13, "thirteen"); rb.insert(8, "eight"); rb.insert(23, "tweenty-three"); rb.insert(100, "a hundred"); rb.insert(40, "forty"); }
int main(int argc, char* argv[]) { std::cout << "RB Tree Test" << std::endl; RBTree rbtree; #if 0 rbtree.insert(30); rbtree.insert(20); rbtree.insert(40); rbtree.insert(11); rbtree.insert(62); rbtree.insert(71); rbtree.insert(65); rbtree.insert(78); rbtree.insert(64); #else rbtree.insert(3); rbtree.insert(7); rbtree.insert(18); rbtree.insert(10); rbtree.insert(23); rbtree.insert(8); rbtree.insert(11); rbtree.insert(26); #endif rbtree.display(rbtree.root_, 1); rbtree.remove(23); rbtree.remove(10); rbtree.display(rbtree.root_, 1); rbtree.remove(7); rbtree.remove(3); rbtree.display(rbtree.root_, 1); rbtree.remove(8); rbtree.remove(11); rbtree.remove(26); rbtree.remove(18); return 0; }
int main(){ AvlTree<char> avl; avl.insert('a'); avl.insert('b'); avl.insert('c'); avl.remove('b'); //cout << avl.toString(); RBTree<char> rb; rb.insert('a'); rb.insert('b'); rb.insert('c'); cout << rb.toString(); //AvlTree<char>::Node* a = new AvlTree<char>::Node('a'); //AvlTree<char>::Node* b = new AvlTree<char>::Node('b'); //AvlTree<char>::Node* c = new AvlTree<char>::Node('c'); //c->left = a; //a->right = b; //cout << c->toString() << endl; //c->left = a->rotateLeft(); //cout << c->toString() << endl; }
int main(int argc,char ** argv) { srand(time(NULL)); RBTree bt; const int size = 10000; int number[size]; for(int i=0; i < size; ++i) { number[i] = i; } int count = size,temp; for(int i=0; i < size; ++i) { temp = rand()%(size-i); bt.insert(number[temp]); number[temp] = number[size-i-1]; } if(bt.checkRB()) cout << "check insert passed!" << endl; else cout << "check insert failed!" << endl; for(int i=0; i < size; ++i) { number[i] = i; } bool flag = true; for(int i=0; i < size; ++i) { temp = rand()%(size-i); if(bt.search(number[temp])->weight != number[temp]) flag = false; number[temp] = number[size-i-1]; } if(flag) cout << "check search passed!" << endl; else cout << "check search failed!" << endl; for(int i=0; i < size; ++i) { number[i] = i; } flag = true; for(int i=0; i < size-10; ++i) { temp = rand()%(size-i); bt.remove(bt.search(number[temp])); if(bt.search(number[temp]) != bt.NIL || !bt.checkRB()) { flag = false; break; } number[temp] = number[size-i-1]; } if(flag) cout << "check remove passed!" << endl; else cout << "check remove failed!" << endl; return 0; }
int main() { RBTree<int> tree; std::vector<int> xs { 40, 17, 88, 91, 96, 25, 23 }; for (const auto& x : xs) { tree.insert(x); std::cout << tree << '\n'; } return 0; }
void simple_insert_RBTree(){ RBTree rbt; std::vector<UInt32> array(1); array[0] = 2; Test_Sorted_Order_Key tk(array, 2); BOOST_REQUIRE(rbt.insert(tk, 0) == true); UInt32 searched; BOOST_REQUIRE(rbt.find(tk, searched) == true); BOOST_REQUIRE(searched == 0); }
void test_insert(){ RBTree<char,int> rb; cout << "*************************************************" << endl; rb.insert('S', 0); //printBST(rb); rb.insert('E', 0); //printBST(rb); rb.insert('A', 0); //printBST(rb); rb.insert('R', 0); //printBST(rb); rb.insert('C', 0); //printBST(rb); rb.insert('H', 0); //printBST(rb); rb.insert('X', 0); //printBST(rb); rb.insert('M', 0); //printBST(rb); rb.insert('P', 0); //printBST(rb); rb.insert('L', 0); printBST(rb); cout << "************************************************" << endl; cout << "min is " << rb.min()<<endl; // while( !rb.empty() ){ // rb.removeMax(); // cout << rb ; // } cout << "=====================================" <<endl; rb.remove('A'); cout << rb; cout << endl; }
void multi_permute_insert_Stepwise_Order_Check(const std::vector<UInt32>& array){ RBTree rbt; std::vector<UInt32> o_contents; for(UInt32 i = 0; i < 10; ++i){ Test_Sorted_Order_Key tk(array, array[i]); BOOST_REQUIRE(rbt.insert(tk, i) == true); rbt.traverse_inorder(o_contents); UInt32 sz = o_contents.size(); BOOST_REQUIRE(sz == ( i + 1 ) ); inorder_check_helper(o_contents, array); } }
int main() { // LinkedList<int> *l = new LinkedList<int>; // l->prependElement(3); // l->prependElement(5); // l->prependElement(6); // l->insertElement(5, new LinkedListElement<int>(12)); // l->print(); // l->deleteElement(5); // l->print(); // std::cout << "============" << std::endl; // RBTree<int> t(5); RBTree<int> t; srand (1); for (int i = 0; i < 18; i++) { // t.insert(rand()); t.insert(i); } // t.insert(40); // t.insert(60); // t.insert(-10); // t.insert(2); // t.insert(91); // t.insert(4); // t.insert(6); // t.insert(18); // t.insert(17); // t.insert(50); printPretty(&t, 1, 0, std::cout); // std::cout << t.min()->data() << std::endl; // std::cout << t.max()->data() << std::endl; t.deleteNode(t.find(11)); printPretty(&t, 1, 0, std::cout); // t.print(); // t.deleteNode(t.find(40), 0); // std::cout << "==" << std::endl; // t.print(); return 0; }
void multi_insert_delete_Objects_RBTree(const std::vector<UInt32>& order_of_removal){ UInt32 sz = order_of_removal.size(); std::vector<Compound_Test> array(sz); BOOST_REQUIRE(sz == 8); array[0].m_name="Gargi";array[0].m_age=4; array[1].m_name="Mithun";array[0].m_age=76; array[2].m_name="Abhay";array[0].m_age=56; array[3].m_name="Jamie";array[0].m_age=9; array[4].m_name="Yang";array[0].m_age=19; array[5].m_name="Jerry";array[0].m_age=52; array[6].m_name="Sherry";array[0].m_age=80; array[7].m_name="Gargi";array[0].m_age=26; RBTree rbt; for(UInt32 i = 0; i < sz; ++i){ Test_Compound_Object_Key<Compound_Test> tco(array, array[i]); BOOST_REQUIRE(rbt.insert(tco, i) == true); UInt32 searched; BOOST_REQUIRE(rbt.find(tco, searched) == true); } for(UInt32 i = 0; i < order_of_removal.size(); ++i){ Test_Compound_Object_Key<Compound_Test> tco(array, array[ order_of_removal[i] ] ); UInt32 searched; BOOST_REQUIRE(rbt.find(tco, searched) == true); BOOST_REQUIRE(rbt.remove(tco) == true); BOOST_REQUIRE(rbt.find(tco, searched) == false); } }
int main() { RBTree<int> a; for (int i = 0; i < 10; ++i) { a.insert(i); a.show(); cout << endl; } for (int i = 0; i < 10; ++i) { a.del(i); a.show(); cout << endl; } cout << endl; cout << "ok\n"; cin.get(); cin.get(); return 0; }
void multi_insert_RBTree(){ RBTree rbt; std::vector<UInt32> array(10); for(UInt32 i = 0; i < 10; ++i){ array[i] = i; Test_Sorted_Order_Key tk(array, array[i]); BOOST_REQUIRE(rbt.insert(tk, i) == true); UInt32 searched; BOOST_REQUIRE(rbt.find(tk, searched) == true); BOOST_REQUIRE(searched == i); } for(UInt32 i = 0; i < 10; ++i){ Test_Sorted_Order_Key tk(array, array[i]); UInt32 searched; BOOST_REQUIRE(rbt.find(tk, searched) == true); BOOST_REQUIRE(searched == i); } }
void test_alg4(){ RBTree<char, int> rbt; rbt.insert('S', 0); cout << "******************after insert S************************" << endl; printBST(rbt); cout << endl; rbt.insert('E', 1); cout << "******************after insert E************************" << endl; printBST(rbt); cout << endl; rbt.insert('A', 2); cout << "******************after insert A************************" << endl; printBST(rbt); cout << endl; rbt.insert('R', 3); cout << "******************after insert R************************" << endl; printBST(rbt); cout << endl; rbt.insert('C', 4); cout << "******************after insert C************************" << endl; printBST(rbt); cout << endl; rbt.insert('H', 5); cout << "******************after insert H************************" << endl; printBST(rbt); cout << endl; rbt.insert('X', 6); cout << "******************after insert X************************" << endl; printBST(rbt); cout << endl; rbt.insert('M', 7); cout << "******************after insert M************************" << endl; printBST(rbt); cout << endl; rbt.insert('P', 8); cout << "******************after insert P************************" << endl; printBST(rbt); cout << endl; rbt.insert('L', 9); cout << "******************after insert L************************" << endl; printBST(rbt); rbt.removeMax(); cout << "******************after remove max**********************" << endl; printBST(rbt); rbt.removeMax(); cout << "******************after remove max**********************" << endl; printBST(rbt); rbt.removeMin(); cout << "******************after remove min**********************" << endl; printBST(rbt); rbt.removeMin(); cout << "******************after remove min**********************" << endl; printBST(rbt); }
///== ///////////////////////////////////////////// int main() { printf("Test of Red-Black Tree class\n"); printHelp(); FILE* f = NULL; // Define a random tree with 20 nodes time_t t = time(0); // Current time in seconds since 1 Jan 1970 srand(t); RBTree tree; char line[256]; while (true) { printf("Command>"); if (fgets(line, 254, stdin) == NULL) break; // Parse a command line[254] = 0; int len = strlen(line); // Remove "\r\n" at the end of line if (len > 0 && line[len-1] == '\n') { line[len-1] = 0; --len; } if (len > 0 && line[len-1] == '\r') { line[len-1] = 0; --len; } int i = 0; // Skip a space in beginning of line while (i < len && isspace(line[i])) ++i; int commandBeg = i; while (i < len && isalpha(line[i])) ++i; int commandEnd = i; int commandLen = commandEnd - commandBeg; if (strncmp("gentree", line+commandBeg, commandLen) == 0 || strncmp("gt", line+commandBeg, commandLen) == 0) { while (i < len && isspace(line[i])) ++i; // Skip a space if (i >= len || !isdigit(line[i])) { printf("Incorrect command.\n"); printHelp(); continue; } int n = atoi(line + i); // Generate a random tree tree.clear(); int j = 0; if (n > 100) n = 100; // Maximum 100 nodes while (j < n) { Integer num(rand() % 100 + 1); RBTreeNode* node; if (!tree.find(&num, tree.root(), &node)) { Integer* v = new Integer(num); tree.insert(node, v); ++j; } } // Print a tree to stdout writeIntegerTree(tree.root(), stdout); } else if (strncmp("readtree", line+commandBeg, commandLen) == 0) { while (i < len && isspace(line[i])) ++i; // Skip a space if ((f = fopen(line+i, "r")) == NULL) { perror("Could not open a file for reading"); continue; } // Read a tree from a file if (readIntegerTree(tree, f)) writeIntegerTree(tree.root(), stdout); else printf("Incorrect format.\n"); fclose(f); f = NULL; } else if (strncmp("writetree", line+commandBeg, commandLen) == 0) { while (i < len && isspace(line[i])) ++i; // Skip a space if (i >= len) { printf("Incorrect command.\n"); printHelp(); continue; } if ((f = fopen(line+i, "w")) == NULL) { perror("Could not open a file for writing"); continue; } writeIntegerTree(tree.root(), f); fclose(f); f = NULL; } ///////////////////// ================================================ else if (strncmp("md", line+commandBeg, commandLen) == 0) { RBTreeNode*node = tree.root(); printf("Max depth = %d.\n", GetDepth(node)); printf("Black depth = %d.\n", GetBlackDepth(node)); } ///////////////////// ================================================ else if (strncmp("quit", line+commandBeg, commandLen) == 0) break; // end if } // end while return 0; }
void benchmark_rb() { srand(time(nullptr)); struct timeval before, after; // Benchmark RB trees and RB trees int max_number_size = 50000000; /* cout << "Timing RB trees sequential insertion" << std::endl; { RBTree<int> t; for (int i = 0; i <= max_number_size; i++) { if (i % 100000 == 0) { int rands[1000]; for (int q = 0; q < 1000; q++) { rands[q] = rand() % max_number_size; } gettimeofday(&before, nullptr); for (int j = 0; j < 1000; j++, i++) { t.insert(rands[j], 0); } gettimeofday(&after, nullptr); print_time("RB insert", i-1000, before, after); } t.insert(rand() % max_number_size, 0); } } cout << "Timing RB trees predecessor search" << std::endl; { RBTree<int> t; vector<RBTreeNode<int>*> nodes; for (int i = 0; i <= max_number_size; i++) { if (i % 100000 == 0 && i != 0) { int number_of_searches = 1000; // generate 10.000 random numbers to search for int rands[number_of_searches]; for (int q = 0; q < number_of_searches; q++) { rands[q] = rand() % nodes.size(); } gettimeofday(&before, nullptr); // Make 10.000 predecessor searches for (int q = 0; q < number_of_searches; q++) { t.predecessor(nodes[rands[q]]->key); } gettimeofday(&after, nullptr); print_time("RB pred", i, before, after); } nodes.push_back(t.insert(rand() % max_number_size, 0)); } } */ cout << "Timing RB trees delete" << std::endl; { RBTree<int> t; vector<int> nodes; for (int i = 0; i <= max_number_size; i++) { if (i % 100000 == 0 && i != 0) { gettimeofday(&before, nullptr); for (int q = 0; q < 1000; q++) { t.remove(nodes.back()); nodes.pop_back(); } gettimeofday(&after, nullptr); print_time("RB delete", i, before, after); for (int q = 0; q < 1000; q++) { nodes.push_back(t.insert(rand() % max_number_size, 0)->value); } } nodes.push_back(t.insert(rand() % max_number_size, 0)->key); } } }
int main() { int len = 0; int * arr = array::read<int>(len); RBTree tree; for (int i = 0; i < len; ++i) { tree.insert(arr[i]); } tree.display(); // int a = 0, b = len - 1, c = len/2; // // tree.remove(arr[a]); // tree.remove(arr[b]); // tree.remove(arr[c]); // // std::cout << "after remove " << arr[a] << ',' << arr[b] << ',' << arr[c] << '\n'; tree.remove(100); tree.remove(70); tree.display(); delete[] arr; return 0; }