int main()
{
int i;
bst_node* root = NULL;
// 利用原地随机化方法将其打乱
int array[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int length = sizeof(array)/sizeof(int);
/* srand(GetTickCount()); */
randomize_in_place(array, length);
print_array(array, length);
for (i = 0; i < length; i++)
{
bst_node* y = (bst_node*)malloc(sizeof(bst_node));
construct_node(y, array[i]);
root = insert_node(root, y);
/* printf("%x\n", (unsigned int)root); */
}
mid_traverse_node(root);
print_node(max_node(root));
print_node(min_node(root));
int s_value;
scanf("%d", &s_value);
fflush(stdin);
while(s_value != -1)
{
bst_node* s_node = search_node(root, s_value);
if (s_node)
{
root = delete_node(s_node);
}
else
{
printf("not in the bst tree\n");
fflush(stdout);
}
length--;
mid_traverse_node(root);
scanf("%d", &s_value);
/* for(i = 0; i<length; i++) */
/* { */
/* int search_key = random(0, length-1); */
/* bst_node* current_node = search_node(root, search_key); */
/* /\* bst_node* precursor = precursor_node(current_node); *\/ */
/* /\* bst_node* successor = successor_node(current_node); *\/ */
/* printf("the search key is %d\n", search_key); */
/* if(current_node->parent) */
/* printf("the parent of %d is %d\n",current_node->key, current_node->parent->key); */
/* fflush(stdout); */
/* /\* if(precursor) *\/ */
/* /\* printf("the precursor of %d is %d\n", current_node->key, precursor->key); *\/ */
/* /\* if(successor) *\/ */
/* /\* printf("the successor of %d is %d\n", current_node->key, successor->key); *\/ */
/* } */
}
return 0;
}
int main()
{
// 测试方法：
// 插入10个元素，遍历该元素，打印
int i;
prbtree root;
nil =(prbtree)malloc(sizeof(rbtree));
nil->color = BLACK;
root = nil;
int array[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int length = sizeof(array)/sizeof(int);
/* srand(GetTickCount()); */
randomize_in_place(array, length);
print_array(array, length);
fflush(stdout);
for (i = 0; i < length; i++)
{
prbtree y = (prbtree)malloc(sizeof(rbt_node));
construct_node(y, array[i]);
// print_node(y);
root = rbt_insert_node(root, y);
printf ("the %dth iteration\n",i + 1);
mid_traverse_node(root);
/* print_node(root); */
/* printf("%x\n", (unsigned int)root); */
}
// mid_traverse_node(root);
// 测试删除操作
randomize_in_place(array, length);
print_array(array, length);
fflush(stdout);
for (i = 0; i < length; ++i)
{
prbt_node x = rbt_search(root, array[i]);
root = rbt_delete_node(root, x);
printf ("the number %d deleted\n",array[i]);
printf ("the %dth iteration\n",i + 1);
mid_traverse_node(root);
}
return 0;
}
void testInsertSort() {
printf("\nNow sorting by insert sort>>>>>>>>>>\n");
startProfileTime();
randomize_in_place(A, ARRAY_SIZE);
print_array(A, ARRAY_SIZE);
endProfileTime("Gen random array");
startProfileTime();
insert_sort(A, ARRAY_SIZE);
endProfileTime("insert sort");
printf("\nSorted array is : ");
print_array(A, ARRAY_SIZE);
}
////////////////////////
//Test Quick sorts
///////////////////////
void testQuickSort() {
printf("\nNow sorting by quick sort>>>>>>>>>>\n");
startProfileTime();
randomize_in_place(A, ARRAY_SIZE);
print_array(A, ARRAY_SIZE);
endProfileTime("Gen random array");
startProfileTime();
quick_sort(A, 1, ARRAY_SIZE);
endProfileTime("quick sort");
printf("\nSorted array is : ");
print_array(A, ARRAY_SIZE);
}
////////////////////////
//Heap sort
///////////////////////
void testHeapSort() {
int i = 0;
printf("\nNow sorting by heap sort>>>>>>>>>>\n");
for(i=0; i<ARRAY_SIZE; i++){
A[i] = i;
}
randomize_in_place(A, ARRAY_SIZE);
printf("\nRandomized array is : ");
print_array(A, ARRAY_SIZE);
startProfileTime();
heap_sort(A, ARRAY_SIZE);
endProfileTime("heap sort");
printf("\nSorted array is : ");
print_array(A, ARRAY_SIZE);
}
// this function is responsible for creating and populating an array
// of size k, and randomizing the locations of its elements
int* generate_array(int k) {
int* arr = (int*) malloc(sizeof(int)*k-1);
int i, j, x, N;
double val;
time_t t;
// init the random number generator
srand((unsigned)time(&t));
// fill the array with values from 1..N
for(i = 0; i <= k-1; i++) {
arr[i] = i+1;
}
N = (int)pow((double)10, 5);
// randomize the elements of the arry for 10^5 iterations
for(i = 0; i < N; i++) {
randomize_in_place(arr, k);
}
return arr;
}
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);
}
