//==================================================================
// 测试红黑树
//==================================================================
void test_redblacktree_delete(RBTree* tree, int key)
{
RBNode* node = RBTree_search(*tree, key);
assert(node != RBTree_nil());
printf("\n删除节点 %d \n", node->key);
node = RBTree_delete(tree, node);
free(node);
RBTree_print(*tree);
}
void testBSTree() {
printf("\nNow is Create Binary tree with node size %d >>>>>>>>>>\n", ARRAY_SIZE);
randomize_in_place(A, ARRAY_SIZE);
// randomize_maxnum(A, ARRAY_SIZE, ARRAY_SIZE);
print_array(A, ARRAY_SIZE);
startProfileTime();
tree_t * tree = tree_create(A, ARRAY_SIZE);
endProfileTime("Create Binary search tree ");
#if 0
printf("\nPre order traverse:\n");
tree_preorder_traverse(tree->root, my_treenode_key_traverse);
printf("\nPost order traverse:\n");
tree_postorder_traverse(tree->root, my_treenode_key_traverse);
printf("\nIn order traverse:\n");
tree_inorder_traverse(tree->root, my_treenode_key_traverse);
#endif
int key = 50;
startProfileTime();
treenode_t * search_result = tree_search(tree->root, key);
endProfileTime("Binary tree search");
if (search_result != get_nil_node()) {
printf("Found key:%d\n", key);
} else {
printf(" Not found key:%d\n", key);
}
tree_left_rotate(tree, search_result);
tree_right_rotate(tree, search_result);
traverse_no_recurise(tree->root, my_treenode_key_traverse);
treenode_t * max, * min;
max = tree_max(tree->root);
min = tree_min(tree->root);
printf("\nmax = %ld\n min = %ld\n", max->key, min->key);
treenode_t * bigger = tree_successor(search_result);
printf("successor = %ld\n", (bigger!=NULL) ? bigger->key : -1);
treenode_t * smaller = tree_predecessor(search_result);
printf("perdecessor = %ld\n", (smaller!=NULL) ? smaller->key : -1);
//Test delete:
treenode_t * deleted_node = RBTree_delete(tree, search_result);
// treenode_t * deleted_node = tree_delete(tree, search_result);
if (deleted_node)
printf("del %p, key=%ld from tree.\n", deleted_node, deleted_node->key);
tree_inorder_traverse(tree->root, my_treenode_key_traverse);
// traverse_no_recurise(tree->root, my_treenode_key_traverse);
int height = get_tree_height(tree->root);
printf("\nget tree h = %d\n", height);
tree_destroy(tree, NULL);
}
void test_redblacktree()
{
const int length = 14;
int array[length] = {
2, 3, 4, 6, 7, 11, 9, 18, 12, 14, 19, 17, 22, 20
};
int i;
RBTree tree = RBTree_nil();
RBNode* node = NULL;
// 插入节点生成树
for (i = 0; i < length; i++) {
node = (RBNode*)malloc(sizeof(RBNode));
node->key = array[i];
node->color = RB_Red;
node->parent = RBTree_nil();
node->leftChild = RBTree_nil();
node->rightChild = RBTree_nil();
RBTree_insert(&tree, node);
}
RBTree_print(tree);
// 插入测试
node = (RBNode*)malloc(sizeof(RBNode));
node->key = 21;
printf("\n插入节点 %d\n", node->key);
RBTree_insert(&tree, node);
RBTree_print(tree);
// 查找测试
i = 6;
node = RBTree_search(tree, i);
if (node != RBTree_nil()) {
printf("\n在红黑树中找到节点 %d\n", node->key);
}
else {
printf("\n在红黑树中找不到节点 %d\n", i);
}
// 删除测试
//
i = 4;// 取值 1, 2, 3, 4，分别对应 case 1, 2, 3, 4
switch (i)
{
case 1: // 兄弟为红色
test_redblacktree_delete(&tree, 3);
break;
case 2: // 兄弟为黑色，且兄弟的两孩子均为黑色
test_redblacktree_delete(&tree, 12);
break;
case 3: // 兄弟为黑色，且兄弟的左孩子为红色，右孩子均为黑色
test_redblacktree_delete(&tree, 19);
break;
case 4: // 兄弟为黑色，且兄弟的右孩子为红色
test_redblacktree_delete(&tree, 9);
break;
}
test_redblacktree_delete(&tree, 21);
// 删除树
for (i = 0; i < length; i++) {
node = RBTree_search(tree, array[i]);
if (node != RBTree_nil()) {
printf("删除 %d\n", node->key);
node = RBTree_delete(&tree, node);
free(node);
}
}
assert(tree == RBTree_nil());
}
