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;
}
