树练习题

#include<stdio.h>
#include<stdlib.h>
typedef int value;
typedef struct btree
{
value data;
struct btree *lchild, *rchild;
int ltag, rtag;
struct btree*parent;
}*datatype,btree;
typedef struct node
{
datatype data;
struct node* next;
}node;
typedef struct stack
{
node *top;
}stack;
typedef struct queue
{
node*rear, *front;
}queue;
void init_stack(stack*&s)
{
s = (stack*)malloc(sizeof(stack));
s->top = NULL;
} v
oid push(stack*s,datatype data)
{
node*temp = (node*)malloc(sizeof(node));
temp->data = data;
temp->next = s->top;
s->top = temp;
} b
ool empty(stack*s)
{
if (s->top == NULL)
return true;
else
return false;
} d
atatype pop(stack*s)
{
if (!empty(s))
{
datatype temp = s->top->data;
s->top = s->top->next;
return temp;
} e
lse
printf("empty stack!\n");
} d
atatype gettop(stack*s)
{
if(!empty(s))
return s->top->data;
else
printf("empty stack!\n");
} v
oid init_queue(queue*&q)
{
q = (queue*)malloc(sizeof(queue));
q->front = q->rear = (node*)malloc(sizeof(node));
q->front->next = NULL;
} v
oid enqueue(queue *q, datatype data)
{
node *temp = (node*)malloc(sizeof(node));
temp->data = data;
q->rear->next = temp;
q->rear = q->rear->next;
} b
ool empty(queue*q)
{
return q->rear == q->front;
} d
atatype dequeue(queue*q)
{
if (empty(q))
printf("empty queue!\n");
else
{
datatype temp = q->front->next->data;
if (q->front->next == q->rear)
q->rear = q->front;
q->front->next = q->front->next->next;
return temp;
}
} d
atatype getfront(queue*q)
{
if (!empty(q))
return q->front->next->data;
else
printf("empty queue!\n");
}v
oid create_btree(btree*&b, value data[], int num)
{
int cnt = 0;
queue*q;
init_queue(q);
while(cnt<num)
{
cnt++;
btree*temp = NULL;
if (data[cnt - 1] != -1)
{
temp = (btree*)malloc(sizeof(btree));
temp->data = data[cnt - 1];
temp->lchild = NULL;
temp->rchild = NULL;
temp->ltag = 0;
temp->rtag = 0;
temp->parent = NULL;
}if
(cnt == 1)
b = temp;
if (!empty(q))
{
btree*parent = getfront(q);
if (temp != NULL&&parent!=NULL)
{
if (cnt % 2 == 0)
{
parent->lchild = temp;
parent->ltag = 1;
}e
lse
{
parent->rchild = temp;
parent->rtag = 1;
} t
emp->parent = parent;
} if
(cnt%2==1)
dequeue(q);
} e
nqueue(q, temp);
}
} v
oid pretraversal(btree*b)
{
btree* root = b;
stack *s;
init_stack(s);
while (root != NULL||!empty(s))
{
if (root == NULL)
root = pop(s)->rchild;
else
{
printf("%d ", root->data);
push(s, root);
root = root->lchild;
}
}
} v
oid intraversal(btree*b)
{ } v
oid posttraversal(btree *b)
{
btree*root = b;
stack*s, *tag;
init_stack(s);
init_stack(tag);
while (root != NULL || !empty(s))
{
if (root == NULL)
{
int tmp = (int)pop(tag);
if (tmp == 1)
{
push(tag, (datatype)2);
root = gettop(s)->rchild;
} e
lse if (tmp == 2)
{
root = pop(s);
printf("%d ", root->data);
root = NULL;
}
} e
lse
{
push(s, root);
push(tag, (datatype)1);
root = root->lchild;
}
}
} v
oid swap(btree*b)
{
if (b != NULL&&b->lchild != NULL&&b->rchild != NULL&&b->lchild->data > b->rchild->data)
{
btree*tmp = b->lchild;
b->lchild = b->rchild;
b->rchild = tmp;
}
} v
oid remove(btree*&b, value x)
{
btree*root = b;
stack*s, *tag;
init_stack(s);
init_stack(tag);
while (root != NULL || !empty(s))
{
if (root == NULL)
{
int tmp = (int)pop(tag);
if (tmp == 1)
{
push(tag, (datatype)2);
root = gettop(s)->rchild;
}
else if (tmp == 2)
{
root = pop(s);
if (root->data == x)
{
printf("delete:");
posttraversal(root);
printf("\n");
if (!empty(s))
if ((int)gettop(tag) == 1)
gettop(s)->lchild = NULL;
else
gettop(s)->rchild = NULL;
else
b = NULL;
} r
oot = NULL;
}
} e
lse
{
push(s, root);
push(tag, (datatype)1);
root = root->lchild;
}
}
} v
oid prethr(btree*b)
{
btree* root = b;
btree*pre = NULL;
stack *s;
init_stack(s);
while (root != NULL || !empty(s))
{
if (root == NULL)
{
root = pop(s);
if (root->rtag == 0)
root = NULL;
else
root = root->rchild;
}
else
{
if (root->ltag == 0)
root->lchild = pre;
if (pre != NULL&&pre->rtag == 0)
pre->rchild = root;
push(s, root);
pre = root;
if (root->ltag == 0)
root= NULL;
else
root = root->lchild;
}
}
} b
tree*getprenxt(btree*b)
{
if (b != NULL)
if (b->ltag == 0)
return b->rchild;
else
return b->lchild;
else return NULL;
} b
tree*getprefwd(btree*b)
{
if (b != NULL)
if (b->ltag == 0)
return b->lchild;
else if (b->parent != NULL)
if(b->parent->lchild == b || b->parent->ltag == 0)
return b->parent;
else
{
btree*tmp = b->parent->lchild;
while (tmp->rtag != 0)
tmp = tmp->rchild;
return tmp;
}
return NULL;
} v
oid inthr(btree*b)
{
btree*root = b;
stack*s;
init_stack(s);
btree*pre = NULL;
while (root != NULL || !empty(s))
{
if (root == NULL)
{
root = pop(s);
if (root->ltag == 0)
root->lchild = pre;
if (pre != NULL&&pre->rtag == 0)
pre->rchild = root;
pre = root;
if (root->rtag == 0)
root = NULL;
else
root = root->rchild;
}e
lse
{
push(s, root);
if (root->ltag == 0)
root = NULL;
else
root = root->lchild;
}
}
}b
tree*getinnxt(btree*b)
{
if (b != NULL)
if (b->rtag == 0)
return b->rchild;
else
{
btree*tmp = b->rchild;
while (tmp->ltag != 0)
tmp = tmp->lchild;
return tmp;
}
return NULL;
}b
tree*getinfwd(btree*b)
{
if (b != NULL)
if (b->ltag == 0)
return b->lchild;
else
{
btree*tmp = b->lchild;
while (tmp->rtag != 0)
tmp = tmp->rchild;
return tmp;
}
return NULL;
} v
oid postthr(btree*b)
{
btree*root = b;
stack*s, *tag;
init_stack(s);
init_stack(tag);
btree*pre = NULL;
while (root != NULL || !empty(s))
{
if (root == NULL)
{
int tmp = (int)pop(tag);
if (tmp == 1)
{
push(tag, (datatype)2);
root = gettop(s);
if (root->rtag == 0)
root = NULL;
else
root = root->rchild;
} e
lse if (tmp == 2)
{
root = pop(s);
if (root->ltag == 0)
root->lchild = pre;
if (pre != NULL&&pre->rtag == 0)
pre->rchild = root;
pre = root;
root = NULL;
}
}
else
{
push(s, root);
push(tag, (datatype)1);
if (root->ltag == 0)
root = NULL;
else
root = root->lchild;
}
}
} b
tree*getpostnxt(btree*b)
{
if (b != NULL)
if (b->rtag == 0)
return b->rchild;
else if (b->parent != NULL)
if (b->parent->rchild == b)
return b->parent;
else if (b->parent->rtag == 0)
return b->parent;
else
{
btree*tmp = b->parent->rchild;
while (tmp->ltag != 0)
tmp = tmp->lchild;
return tmp;
}
return NULL;
} b
tree*getpostfwd(btree*b)
{
if (b != NULL)
if (b->ltag == 0)
return b->lchild;
else if (b->ltag == 1)
return b->rchild;
else
return b->lchild;
return NULL;
} v
oid create_bst(btree*&b, value data[],int len)
{
b = NULL;
for (int i = 0; i < len; i++)
{
btree*tmpnode = (btree*)malloc(sizeof(btree));
tmpnode->data = data[i];
tmpnode->lchild = NULL;
tmpnode->ltag = 0;
tmpnode->parent = NULL;
tmpnode->rchild = NULL;
tmpnode->rtag = 0;
if (b != NULL)
{
btree*tmp = b;
btree*pre = NULL;
do
{
pre = tmp;
if (tmp->data > tmpnode->data)
tmp = tmp->lchild;
else
tmp = tmp->rchild;
} while (tmp != NULL);
if (pre->data > tmpnode->data)
pre->lchild = tmpnode;
else
pre->rchild = tmpnode;
} e
lse
b = tmpnode;
}
} v
oid free_btree(btree*b)
{
btree*root = b;
stack*s, *tag;
init_stack(s);
init_stack(tag);
while (root != NULL || !empty(s))
{
if (root == NULL)
{
int tmp = (int)pop(tag);
if (tmp == 1)
{
push(tag, (datatype)2);
root = gettop(s)->rchild;
}e
lse if (tmp == 2)
{
root = pop(s);
printf("%d ", root->data);
free(root);
root = NULL;
}
}e
lse
{
push(s, root);
push(tag, (datatype)1);
root = root->lchild;
}
}
}v
oid remove_bst_node(btree*&b, value x)
{
btree*pre = NULL;
btree*p = b;
while (p != NULL)
{
if (p->data < x)
{
pre = p;
p = p->rchild;
}e
lse if (p->data > x)
{
pre = p;
p = p->lchild;
}e
lse
{
if (pre != NULL)
{
btree*result=NULL;
if (p->lchild != NULL&&p->rchild==NULL)
{
result = p->lchild;
}e
lse if (p->lchild == NULL&&p->rchild != NULL)
{
result = p->rchild;
} e
lse if(p->lchild != NULL&&p->rchild != NULL)
{
btree*tmp = p->lchild, *father = p;
while (tmp->rchild != NULL)
{
father = tmp;
tmp = tmp->rchild;
} if
(father == p)
{
tmp->rchild = p->rchild;
result = tmp;
} e
lse
{
father->rchild = tmp->lchild;
tmp->lchild = p->lchild;
tmp->rchild = p->rchild;
result = tmp;
}
} if
(pre->lchild == p)
pre->lchild =result;
else
pre->rchild = result;
free(p);
} e
lse {
free(b);
b = NULL;
break;
}
break;
}
}
} b
ool is_bst(btree*b)
{
btree*root = b;
stack*s;
init_stack(s);
while (root != NULL || !empty(s))
{
if (root == NULL)
{
root = pop(s);
// printf("%d ", root->data);
if (root->lchild != NULL)
if (root->lchild->data > root->data)
return false;
if (root->rchild != NULL)
if (root->rchild->data < root->data)
return false;
root = root->rchild;
} e
lse
{
push(s, root);
root = root->lchild;
}
} r
eturn true;
} i
nt main()
{
value test[] = {1,2,3,4,5,6,7,8,9,10};
btree *b=NULL;
create_btree(b, test, 10);
printf("%d", is_bst(b));
getchar();
}