二叉排序树

二叉排序树：根节点大于左子节点，但小于右子节点
顺序： 左 < 根 < 右

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct Node {
	int data;
	struct Node *lchild, *rchild;
} Node;

typedef struct Tree {
	struct Node *root;
	int n;
} Tree;

Node *init_node(int val) {
	Node *p = (Node*)malloc(sizeof(Node));
	p->data = val;
	p->lchild = p->rchild = NULL;
	return p;
}

Tree *init_tree() {
	Tree *tree = (Tree *)malloc(sizeof(Tree));
	tree->root = NULL;
	tree->n = 0;
	return tree;
}

void clear_node(Node *node) {
	if (!node) return ;
	clear_node(node->lchild);
	clear_node(node->rchild);
	free(node);
	return ;
}

void clear_tree(Tree *tree) {
	if (!tree) return ;
	clear_node(tree->root);
	free(tree);
	return ;
}

Node *insert_node(Node *root, int val, int *flag) {
	if (!root) {
		*flag = 1;
		return init_node(val);
	}
	if (root->data == val) return root;
	if (val < root->data) root->lchild = insert_node(root->lchild, val, flag); 
	else root->rchild = insert_node(root->rchild, val, flag);
	return root;
}

void insert(Tree *tree, int val) {
	int flag = 0;
	tree->root = insert_node(tree->root, val, &flag);
	tree->n += flag;
	return ;
}

void pre_order_node(Node *node) {
	if (!node) return ;
	printf("%d ", node->data);
	pre_order_node(node->lchild);
	pre_order_node(node->rchild);
}

void pre_order(Tree *tree) {
	if (!tree) return ;
	printf("%s: ", __func__);
	pre_order_node(tree->root);
	printf("\n");
}

void in_order_node(Node *node) {
	if (!node) return ;
	in_order_node(node->lchild);
	printf("%d ", node->data);
	in_order_node(node->rchild);
}

void in_order(Tree *tree) {
	if (!tree) return ;
	printf("%s: ", __func__);
	in_order_node(tree->root);
	printf("\n");
}

void post_order_node(Node *node) {
	if (!node) return ;
	post_order_node(node->lchild);
	post_order_node(node->rchild);
	printf("%d ", node->data);
}

void post_order(Tree *tree) {
	if (!tree) return ;
	printf("%s: ", __func__);
	post_order_node(tree->root);
	printf("\n");
}

void output_node(Node *node) {
	if (!node) return ;
	printf("%d", node->data);
	if (node->lchild == NULL && node->rchild == NULL) return ;
	printf("(");
	output_node(node->lchild);
	printf(",");
	output_node(node->rchild);
	printf(")");
	return ;
}

void output(Tree *tree) {
	if (!tree) return ;
	printf("tree(%d) : ", tree->n);
	output_node(tree->root);
	printf("\n");
	return ;
}

int main() {
	srand(time(0));
	Tree *tree = init_tree();

	for (int i = 0; i < 9; i++) {
		int val = rand() % 100;
		insert(tree, val);
		output(tree);
	}
	pre_order(tree);
	in_order(tree);
	post_order(tree);

	clear_tree(tree);
	return 0;
}

输出样例：

tree(1) : 81
tree(2) : 81(,98)
tree(3) : 81(74,98)
tree(4) : 81(74(22,),98)
tree(5) : 81(74(22(20,),),98)
tree(6) : 81(74(22(20,24),),98)
tree(7) : 81(74(22(20,24(,41)),),98)
tree(8) : 81(74(22(20,24(,41(,60))),),98)
tree(9) : 81(74(22(20,24(,41(,60))),),98(89,))
pre_order: 81 74 22 20 24 41 60 98 89 
in_order: 20 22 24 41 60 74 81 89 98 
post_order: 20 60 41 24 22 74 89 98 81