C语言二叉树

#include <stdio.h>
#include<stdlib.h>
#include<algorithm>
#include<queue>
#include<iostream>
struct BstNode
{
	int data;
	BstNode* left;
	BstNode* right;

};
BstNode* rootPtr;
 BstNode* Insert(BstNode* root,int data) {
	
	if (root==NULL)
	{
		root = GetNewNode(data);
	}
	else if (data<=root->data)
	{
		root->left = Insert(root->left, data);

	}
	else
	{
		root->right = Insert(root->right, data);
	}
	return root;



}
 struct Node {
	 char data;
	 Node* left;
	 Node* right;

 };
 bool Search(BstNode* root,int data) {
	 if (root == NULL) return false;
	 else if (root->data == data) return true;
	 else if (data <= root->data) return Search(root->left, data);
	 else return Search(root->right, data);
 
 }
BstNode* GetNewNode(int data) {
	BstNode* newNode = (BstNode*)malloc(sizeof(BstNode));
	newNode->data = data;
	newNode->left = newNode->right = NULL;
	return newNode;


}
int FindMin(BstNode* root) {
	BstNode* current = root;
	if (root==NULL)
	{
		return -1;

	}
	else if (root->left == NULL)
	{
		return root->data;
	}
	return FindMin(root->left);
	while (current->left!=NULL)
	{
		current = current->left;
	}
	return current->data;
	
}
int FindHeight(struct Node* root) {
	if (root==NULL)
	{
		return -1;

	}
	return max(FindHeight(root->left), FindHeight(root->right)) + 1;

}
int max(int a,int b) {
	if (a>b)
	{
		return a;

	}
	else
	{
		return b;
	}
}
void preorder(Node* root) {
	if (root == NULL) return;
	printf("%s", root->data);
	preorder(root->left);
	preorder(root->right);
}
void Inorder(Node* root) {
	if (root == NULL) return;
	Inorder(root->left);
	printf("%s", root->data);
	Inorder(root->right);
}
void Postorder(Node* root) {
	if (root == NULL) return;
	Postorder(root->left);
	Postorder(root->right);
	printf("%s", root->data);
}
bool IsSubtreeLesser(Node* root, int value) {
	if (root == NULL)return true;
	if (root->data > value
		&& IsSubtreeGreater(root->left, value)
		&& IsSubtreeGreater(root->left, value))
		return true;
	else
		return false;


}
bool IsSubtreeGreater(Node* root, int value) {
	if (root == NULL)return true;
	if (root->data > value
		&& IsSubtreeGreater(root->left, value)
		&& IsSubtreeGreater(root->left, value))
		return true;
	else
		return false;


}
bool IsBinarySearchTree(Node* root) {
	if (root == NULL)return true;
	if (IsSubtreeLesser(root->left, root->data) 
		&& IsSubtreeGreater(root->right, root->data)
		&& IsBinarySearchTree(root->left) 
		&& IsBinarySearchTree(root->right))
		return true;
	else
		return false;

	

}
struct Node* Delete(struct Node* root,int data) {
	if (root == NULL) return root;
	else if (data < root->data) root->left=Delete(root->left, data);
	else if (data > root->data) root->right = Delete(root->right, data);
	else
	{
		if (root->left&&root->right==NULL)//No child
		{
			delete root;
			root = NULL;
			return root;
		}
		else if (root->left==NULL)
		{
			struct Node* temp = root;
			root = root->right;
			delete temp;

		}
		else if (root->right==NULL)
		{
			struct Node* temp = root;
			root = root->left;
			delete temp;

		}
		else
		{
			struct Node* temp = FindMin(root->right);
			root->data = temp->data;
			root->right = Delete(root->right, temp->data);


			//children
		}
	}
	return root;

}
int main() {
	BstNode* root;
	root = NULL;
	Insert(root, 15);

	return 0;

}