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);
}
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);
}
}
//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;
}
int main()
{
RBTree tree;
tree.rbInsert(std::make_pair(0, 0));
tree.rbDelete(0);
return 0;
}
void TestRbTree::testCase1() {
RBTree<int, int> tree;
vector<int> v;
int i =0;
for (int i = 0; i < 20; ++i) {
v.push_back(i);
}
random_shuffle(v.begin(), v.end());
copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
cout << endl;
stringstream sstr;
for (i = 0; i < v.size(); ++i) {
tree.Insert(makePair(v[i], i));
cout << "insert:" << v[i] << endl; //添加结点
}
for (i = 0; i < v.size(); ++i) {
cout << "Delete:" << v[i] << endl;
tree.Delete(v[i]); //删除结点
tree.InOrderTraverse();
}
cout << endl;
tree.InOrderTraverse();
std::cout << "case1 passed" << std::endl;
}
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);
}
}
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_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);
}
}
int main()
{
RBTree<int, int> rb;
int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
rb.Insert(a[i], a[i]);
}
rb.InOrder();
cout<<rb.IsBalanceTree();
return 0;
}
void TestRBTree()
{
int arr[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
int len = sizeof(arr) / sizeof(arr[0]);
RBTree<int, int> t;
for (int i = 0; i < len; i++)
{
t.Insert(arr[i], i);
t.InOrder_NonR();
cout << "Is?" << t.Check() << endl;
}
}
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);
}
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;
}
int main()
{
RBTree<int> a;
for (int i = 0; i < 10; ++i)
a.Insert(i);
a.show();
for (int i = 2; i < 5; ++i)
a.Del(i);
a.show();
cin.get();
return 0;
}
void TestRBTree()
{
int array[] = { 4, 5, 13, 28, 5, 19, 18, 37, 10, 20 };
RBTree<int, int> t;
for (size_t i = 0; i < 10; ++i)
{
t.Insert(array[i], array[i]);
}
t.InOrder();
cout << endl;
cout << "IsBlance?" << " " << t.IsBlance() << endl;
}
void Test()
{
RBTree<int,int> rbt;
//int arr[] = {16,3,7,11,9,26,18,14,15};
int arr[] = {48,12,56,32,99,11,10,78,22};
int size = sizeof(arr)/sizeof(arr[0]);
for (int i = 0;i < size;i++)
{
rbt.Insert(arr[i],i);
cout<<"IsBlance? "<<rbt.IsBlance()<<endl;
}
rbt.InOrder();
cout<<"IsBlance? "<<rbt.IsBlance()<<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);
}
}
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)
{
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(){
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;
}
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);
}
}
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;
}
int main()
{
int i;
RBTree rbt;
rbtree t = rbt.rbtree_create();
for (i = 0; i < 12; i++)
{
int x = rand() % 10;
int y = rand() % 10;
print_tree(t);
printf("Inserting %d -> %d\n\n", x, y);
rbt.rbtree_insert(t, (void*)x, (void*)y, compare_int);
assert(rbt.rbtree_lookup(t, (void*)x, compare_int) == (void*)y);
}
for (i = 0; i < 15; i++)
{
int x = rand() % 10;
print_tree(t);
printf("Deleting key %d\n\n", x);
rbt.rbtree_delete(t, (void*)x, compare_int);
}
return 0;
}
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;
}
int main(int argc, const char * argv[]) {
RBTree<int> tree;
Helper::print("Welcome to the int RB Tree tester. Jonathan Ginsburg (C) September 2015.");
while (true) {
Helper::print("\t1 for inserting in tree.");
Helper::print("\t2 for deleting from tree.");
Helper::print("\t3 for searching in tree.");
Helper::print("\t4 for printing tree in ascending order.");
Helper::print("\t5 for printing tree in descending order.");
// Helper::print("\t6 for verifying legality of tree according to AVL rules.");
Helper::print("\t0 for terminating program.");
int input = Helper::read<int>(">> Enter your choice: ");
switch (input) {
case 0:
return 0;
break;
case 1:
try {
tree.Insert(Helper::read<int>(">> Enter value to insert: "));
} catch (const char * e) {
Helper::print(e);
}
break;
case 2:
try {
tree.Erase(Helper::read<int>(">> Enter value to erase: "));
} catch (const char * e) {
Helper::print(e);
}
break;
case 3:
try {
std::string wasFound = tree.Search(Helper::read<int>("Enter value to search for: ")) ? " " : " not ";
std::cout << ">> Value is" << wasFound << "in the tree." << std::endl;
} catch (const char * e) {
Helper::print(e);
}
break;
case 4:
tree.PrintAscending();
break;
case 5:
tree.PrintDescending();
break;
// case 6:
// std::string isLegal = tree.IsLegal() ? "Tree is legal." : "Tree is not legal.";
// Helper::print(isLegal);
// break;
}
}
}
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);
}
}
int main(int argc,char* argv[])
{
RBTree<int> tree;
int array[] = {12,1,9,2,0,11,7,19,4,15,18,5,14,13,10,16,6,3,8,17};
for(int i=0;i<sizeof(array)/sizeof(array[0]);i++)
tree.Insert(array[i]);
std::cout<<"preOrder:"<<std::endl;
tree.PreOrderTraver();
std::cout<<"delete 6 num,preOrder:"<<std::endl;
tree.Delete(12);
tree.Delete(1);
tree.Delete(9);
tree.Delete(2);
tree.Delete(0);
tree.Delete(11);
tree.PreOrderTraver();
}
int main() {
RBTree<int, Comparable> tree;
tree.insertData("Number 5", new int(5));
tree.insertData("Number 7", new int(7));
tree.insertData("Number 9", new int(9));
tree.insertData("Number 1000", new int(1000));
std::cout << *tree.getData("Number 9") << std::endl;
tree.deleteData("Number 9");
std::cout << (int)(tree.getData("Number 9") == NULL) << std::endl;
return 0;
}
void test_rbt(){
RBTree<int, string> rb;
create_rbt(rb);
cout << rb;
cout << "is empty? " << rb.empty()<<endl;
cout << "height of rb is ? " << rb.height() <<endl;
cout << "min key = " << rb.min() << endl;
cout << "max key = " << rb.max() << endl;
cout << "max key rank of 30 is " << rb.rank(30) << endl;
cout << "4th key is " << rb.select(4) << endl;
cout << "keys are: " << endl;
// deque<int> keys = rb.keys();
// for( deque<int>::iterator it = keys.begin(); it != keys.end(); ++it){
// cout << *it << " ";
// }
rb.removeMin();
cout << rb ;
cout << "=====================================" <<endl;
cout << endl;
}
int main()
{
RBTree<int> tree;
int i;
int t[]={0,1,2,3,4,5,6,7,8,-1,-2,-3,-4,-5,-6,-7,-8};
for(i=0;i<17;i++)
tree.Insert(t[i]);
cout<<"InROrder:"<<endl;
tree.InROrder();
cout<<"\nOutLevelROrder:"<<endl;
tree.OutLevelROrder();
cout<<"\nOutLevelROrder:"<<endl;
tree.Delete(3);
tree.OutLevelROrder();
return 0;
}
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;
}
