Node<T>* min_element(Node<T>* node)
{
if(is_real(node))
{
node = min_node(node, min_element(node->left));
node = min_node(node, min_element(node->right));
}
return node;
}
// preassume that the root is not null
bst_node* successor_node(bst_node* current)
{
bst_node* parent = current->parent;
// 如果存在右孩子，则后继为当前结点右子树中最小的那个结点
if(current->right)
{
return min_node(current->right);
}
else if(parent)
{
while(parent && parent->left != current)
{
current = parent;
parent = parent->parent;
}
if (parent)
return parent;
else
return NULL;
}
else
{
return NULL;
}
}
static struct node* min_node(struct node* root)
{
if (root == NULL)
return root;
if (root->left != NULL)
return min_node(root->left);
else
return root;
}
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;
}
TREE successor(TREE tree_p)
{
if(tree_p->right != NULL)
return min_node(tree_p->right);
while(tree_p->parent->right == tree_p)
tree_p = tree_p->parent;
return tree_p->parent;
}
bool is_bst(NodeBase* node)
{
if (is_nil(node))
{
return true;
}
auto m = node;
m = max_node(m, max_element(node->left));
m = min_node(m, min_element(node->right));
return m == node && is_bst(node->left) && is_bst(node_>right);
}
int main(void)
{
struct node* root = NULL;
//struct node* root2 = NULL;
struct node *find = NULL;
char str[1024];
root = insert(root, 10);
root = insert(root, 15);
root = insert(root, 9);
root = insert(root, 8);
root = insert(root, 13);
root = insert(root, 7);
root = insert(root, 5);
root = insert(root, 18);
root = insert(root, 22);
root = insert(root, 3);
root = insert(root, 4);
root = insert(root, 2);
root = insert(root, 1);
print_ascii_tree(root);
find = search(root, 18);
print_ascii_tree(root);
find = search(root, 22);
printf("\n\n\nDATA found is %d\n", find->data);
find = min_node(root);
printf("Min in this tree is %d\n", find->data);
find = max_node(root);
printf("Mx in this tree is %d\n", find->data);
print_ascii_tree(root);
preorder(root);
printf("\n");
inorder(root);
printf("\n");
postorder(root);
printf("\n");
printf("DEPTH is %d\n", depth(root));
tree_to_string(root, str);
printf("The STR generated is %s\n", str);
//string_to_tree(&root2, str);
//print_ascii_tree(root2);
printf("COUNT is %d\n",nodes(root));
bool res = hassum(root, 45);
printf("Bool val is %d\n", (int)res);
levelorder(root);
return 0;
}
//---------------rbtree debug------------------------------------//
int
rbtree_test(void)
{
int i, j, len, slice, ret;
struct timeval tv;
struct rbnode node, *pn = NULL;
struct ttlnode *tn = NULL;
struct rbtree *rbt = NULL;
rbt = create_rbtree(rbt_comp_ttl_gt, NULL);
if (rbt == NULL)
dns_error(0, "create rbtree");
node = rbt->nil; //nil
slice = 8000000;
//for(i = 0;i < n;i ++)
//{
for (j = 0; j < slice; j++) {
len = random() % 30;
tn = malloc(sizeof(struct ttlnode) + len);
if (tn == NULL)
printf("oom\n");
tn->exp = j;
for (i = 0; i < len; i++)
tn->data[i] = 'a' + i;
node.key = tn;
ret = insert_node(rbt, &node);
if (ret != 0)
printf("insert error\n");
}
printf("insert all\n");
sleep(2);
for (j = 0; j < slice; j++) {
pn = min_node(rbt);
if (pn != NULL) {
tn = delete_node(rbt, pn);
free(tn);
} else
printf("error\n");
}
printf("delete all\n");
sleep(5);
//}
if (free_rbtree(rbt) != 0)
dns_error(0, "free");
//get_time_usage(&tv,0);
return 0;
}
// max
int max_node(int depth, int side, XY *move)
{
int best = -INFINITY, value;
int nmoves;
XY moves[MOVENUM], opp[MOVENUM];
int pre_board[8][8];
int i;
if (depth == DEPTH)
return eval_func();
// 手を生成
nmoves = generate_moves(side, moves);
// 手がないとき
if (nmoves == 0)
{
if (generate_moves(-side, opp) == 0) // 相手もおけないときは終了
return get_terminal_value();
else // 違うときはパス
moves[nmoves++] = PASSMOVE;
}
// たどっていく
for (i = 0; i < nmoves; i++)
{
memcpy(pre_board, board, sizeof(board)); // 盤面の保存
place_disk(side, moves[i]); // 一手進める
// 再帰(recursive)
value = min_node(depth + 1, -side, move);
memcpy(board, pre_board, sizeof(board)); // 戻す
// 値の更新
if (value >= best)
{
best = value;
if (depth == 0)
*move = moves[i];
}
}
return best;
}
int main(void)
{
int i, j;
/*
fi=fopen("nocows.in","r");
fo=fopen("nocows.out","w");
fscanf(fi,"%d %d",&N,&K);
fclose(fi);
*/
K = 13;
for (N = min_node(K); N <= max_node(K); N = N+2) {
for (i=1;i<=K;i++)
dp[1][i]=1;
dynamicp();
printf("N: %d, K: %d, %ld\n", N, K, ((dp[N][K]+9901-dp[N][K-1])%9901));
for (i = 0; i <= N; i++)
for (j = 0; j <= K; j++)
dp[i][j]=0;
}
//fclose(fo);
return 0;
}
int
check_ttl_expire(struct author *author)
{
time_t now;
struct ttlnode *tn = NULL;
struct rbnode *pn = NULL;
mbuf_type *mbuf;
int ret = -1;
struct rbtree *rbt = NULL;
mbuf = mbuf_alloc();
if (NULL == mbuf)
return -1;
now = global_now;
/* ds = author->s->datasets; */
rbt = author->s->ttlexp;
pthread_spin_lock(&rbt->lock);
pn = min_node(rbt);
while (pn != NULL) {
tn = pn->key;
//if exp was 12, now was 11, start
//if exp was 12, now was 5, break
if (tn->exp > (now + TTL_UPDATE)) //3 secs after it will not expire
break;
/* printf("ttl refresh "); */
/* dbg_print_td(tn->data); */
tn = delete_node(rbt, pn);
pthread_spin_unlock(&rbt->lock);
if (tn != NULL) {
memset(mbuf, 0, sizeof(mbuf_type));
mbuf->qname = tn->type; //type
mbuf->qtype = tn->type;
mbuf->dlen = tn->dlen;
memcpy(&(mbuf->lowerdomain), tn->lowerdomain, sizeof(packet_type));
int i;
for (i = 0; i < tn->lowerdomain->label_count; i++)
{
mbuf->lowerdomain.label[i] = mbuf->lowerdomain.domain + mbuf->lowerdomain.label_offsets[i];
}
mbuf->qhash = &(mbuf->lowerdomain.hash[0]);
mbuf->td = mbuf->lowerdomain.domain;
mbuf->qing = mbuf->td;
mbuf->qlen = mbuf->dlen;
mbuf->cid = 0;
mbuf->fd = -1;
init_qoutinfo(mbuf);
ret = htable_insert_list(author->s->qlist, tn->data, tn->dlen, tn->type, (uchar *)mbuf, 0, NULL, tn->hash); //not replace
if (HTABLE_INSERT_RET_NORMAL == ret)
{
mbuf = mbuf_alloc();
if (NULL == mbuf)
{
free(tn->lowerdomain);
free(tn);
return -1;
}
}
//else querying lost
free(tn->lowerdomain);
free(tn);
}
pthread_spin_lock(&rbt->lock);
pn = min_node(rbt);
}
mbuf_free(mbuf);
pthread_spin_unlock(&rbt->lock);
return 0;
}
/* transform the graph to a shortest-path tree by marking tree edges */
void
mapit()
{ register p_node n;
register p_link l;
p_link lparent;
static int firsttime = 0;
vprintf(stderr, "*** mapping\n");
Tflag = Tflag && Vflag; /* tracing here only if verbose */
/* re-use the hash table space for the heap */
Heap = (p_link *) Table;
Hashpart = pack(0L, Tabsize - 1);
/* expunge penalties from -a option and make circular copy lists */
resetnodes();
if (firsttime++) {
if (Linkout && *Linkout) /* dump cheapest links */
showlinks();
if (Graphout && *Graphout) /* dump the edge list */
dumpgraph();
}
/* insert Home to get things started */
l = newlink(); /* link to get things started */
getlink(l)->l_to = Home;
(void) dehash(Home);
insert(l);
/* main mapping loop */
remap:
Heaphighwater = Nheap;
while ((lparent = min_node()) != 0) {
chkheap(1);
getlink(lparent)->l_flag |= LTREE;
n = getlink(lparent)->l_to;
if (Tflag && maptrace(n, n))
fprintf(stderr, "%s -> %s mapped\n",
getnode(getnode(n)->n_parent)->n_name,
getnode(n)->n_name);
if (getnode(n)->n_flag & MAPPED)
die("mapped node in heap");
getnode(n)->n_flag |= MAPPED;
/* add children to heap */
heapchildren(n);
}
vprintf(stderr, "heap high water mark was %ld\n", Heaphighwater);
/* sanity check on implementation */
if (Nheap != 0)
die("null entry in heap");
if (Hashpart < Tabsize) {
/*
* add back links from unreachable hosts to
* reachable neighbors, then remap.
*
* asymptotically, this is quadratic; in
* practice, this is done once or twice.
*/
backlinks();
if (Nheap)
goto remap;
}
if (Hashpart < Tabsize) {
fputs("You can't get there from here:\n", stderr);
for ( ; Hashpart < Tabsize; Hashpart++) {
fprintf(stderr, "\t%s", getnode(Table[Hashpart])->n_name);
if (getnode(Table[Hashpart])->n_flag & ISPRIVATE)
fputs(" (private)", stderr);
putc('\n', stderr);
}
}
}
