搜索二叉树

SearchBinaryTree.h

#pragma once

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

typedef int _SBTDataType;

typedef struct SearchBinaryTreeNode
{
	struct SearchBinaryTreeNode * _left;
	struct SearchBinaryTreeNode * _right;
	_SBTDataType _data;
}SearchBinaryTreeNode, *pSearchBinaryTreeNode;

pSearchBinaryTreeNode BuySearchBinaryTreeNode(_SBTDataType x);

int InsertSearchBinaryTree(pSearchBinaryTreeNode * tree, _SBTDataType x);
int RemoveSearchBinaryTree(pSearchBinaryTreeNode * tree, _SBTDataType x);
pSearchBinaryTreeNode FindSearchBinaryTree(pSearchBinaryTreeNode * tree, _SBTDataType x);

int InsertSearchBinaryTreeR(pSearchBinaryTreeNode * tree, _SBTDataType x);
int RemoveSearchBinaryTreeR(pSearchBinaryTreeNode * tree, _SBTDataType x);
pSearchBinaryTreeNode FindSearchBinaryTreeR(pSearchBinaryTreeNode * tree, _SBTDataType x);

SearchBinaryTree.c

#include"SearchBinaryTree.h"

pSearchBinaryTreeNode BuySearchBinaryTreeNode(_SBTDataType x)
{
	pSearchBinaryTreeNode node = (pSearchBinaryTreeNode)malloc(sizeof(SearchBinaryTreeNode));
	assert(node);
	node->_data = x;
	node->_left = NULL;
	node->_right = NULL;
	return node;
}

int InsertSearchBinaryTree(pSearchBinaryTreeNode * tree, _SBTDataType x)
{
	pSearchBinaryTreeNode cur = NULL, parent = NULL;
	if (*tree == NULL)
	{
		*tree = BuySearchBinaryTreeNode(x);
		return 1;
	}
	cur = *tree;
	while (cur)
	{
		if (cur->_data > x)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_data < x)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return 0;
		}
	}
	if (parent->_data > x)
	{
		parent->_left = BuySearchBinaryTreeNode(x);
	}
	else
	{
		parent->_right = BuySearchBinaryTreeNode(x);
	}
	return 1;
}

int RemoveSearchBinaryTree(pSearchBinaryTreeNode * tree, _SBTDataType x)
{
	pSearchBinaryTreeNode cur = *tree, parent = NULL;
	while (cur)
	{
		if (cur->_data > x)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_data < x)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			if (cur->_left == NULL)
			{
				if (parent == NULL)
				{
					*tree = cur->_right;
				}
				else
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}
			}
			else if (cur->_right == NULL)
			{
				if (parent == NULL)
				{
					*tree = cur->_left;
				}
				else
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
			}
			else
			{
				pSearchBinaryTreeNode replace = cur->_right;
				while (replace->_left)
				{
					replace = replace->_left;
				}
				cur->_data = replace->_data;
				return RemoveSearchBinaryTree(&cur->_right, replace->_data);
			}
			free(cur);
			return 1;
		}
	}
	return 0;
}

pSearchBinaryTreeNode FindSearchBinaryTree(pSearchBinaryTreeNode * tree, _SBTDataType x)
{
	pSearchBinaryTreeNode cur = *tree;
	while (cur)
	{
		if (cur->_data > x)
		{
			cur = cur->_left;
		}
		else if (cur->_data < x)
		{
			cur = cur->_right;
		}
		else
		{
			return cur;
		}
	}
	return NULL;
}

int InsertSearchBinaryTreeR(pSearchBinaryTreeNode * tree, _SBTDataType x)
{
	if (*tree == NULL)
	{
		*tree = BuySearchBinaryTreeNode(x);
		return 1;
	}
	if ((*tree)->_data > x)
	{
		return InsertSearchBinaryTreeR(&(*tree)->_left, x);
	}
	else if ((*tree)->_data < x)
	{
		return InsertSearchBinaryTreeR(&(*tree)->_right, x);
	}
	else
	{
		return 0;
	}
}

int RemoveSearchBinaryTreeR(pSearchBinaryTreeNode * tree, _SBTDataType x)
{
	if (*tree == NULL)
	{
		return 0;
	}
	if ((*tree)->_data > x)
	{
		return RemoveSearchBinaryTreeR(&(*tree)->_left, x);
	}
	else if ((*tree)->_data < x)
	{
		return RemoveSearchBinaryTreeR(&(*tree)->_right, x);
	}
	else
	{
		pSearchBinaryTreeNode del = *tree;
		if ((*tree)->_left == NULL)
		{
			*tree = (*tree)->_right;
			free(del);
		}
		else if ((*tree)->_right == NULL)
		{
			*tree = (*tree)->_left;
			free(del);
		}
		else
		{
			pSearchBinaryTreeNode replace = (*tree)->_right;
			while (replace->_left)
			{
				replace = replace->_left;
			}
			(*tree)->_data = replace->_data;
			return RemoveSearchBinaryTreeR(&(*tree)->_right, replace->_data);
		}
	}
	return 1;
}

pSearchBinaryTreeNode FindSearchBinaryTreeR(pSearchBinaryTreeNode * tree, _SBTDataType x)
{
	if (*tree == NULL)
	{
		return NULL;
	}
	if ((*tree)->_data > x)
	{
		return FindSearchBinaryTreeR(&(*tree)->_left, x);
	}
	else if ((*tree)->_data < x)
	{
		return FindSearchBinaryTreeR(&(*tree)->_right, x);
	}
	else
	{
		return *tree;
	}
}

Test.c

#include"SearchBinaryTree.h"

void InOrderSearchBinaryTree(pSearchBinaryTreeNode tree)
{
	if (tree == NULL)
	{
		return NULL;
	}
	InOrderSearchBinaryTree(tree->_left);
	printf("%d ", tree->_data);
	InOrderSearchBinaryTree(tree->_right);
}

void testSearchBinaryTree()
{
	int i = 0;
	pSearchBinaryTreeNode tree = NULL;
	int arr[] = { 5,3,4,1,7,8,2,6,0,9,10 };
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		InsertSearchBinaryTree(&tree, arr[i]);
	}

	printf("%p\n", FindSearchBinaryTree(&tree, 5));
	printf("%p\n", FindSearchBinaryTree(&tree, 11));

	InOrderSearchBinaryTree(tree);
	printf("\n");

	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		RemoveSearchBinaryTree(&tree, arr[i]);
		InOrderSearchBinaryTree(tree);
		printf("\n");
	}
}

void testSearchBinaryTreeR()
{
	int i = 0;
	pSearchBinaryTreeNode tree = NULL;
	int arr[] = { 5,3,4,1,7,8,2,6,0,9,10 };
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		InsertSearchBinaryTreeR(&tree, arr[i]);
	}

	printf("%p\n", FindSearchBinaryTreeR(&tree, 5));
	printf("%p\n", FindSearchBinaryTreeR(&tree, 11));

	InOrderSearchBinaryTree(tree);
	printf("\n");

	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		RemoveSearchBinaryTreeR(&tree, arr[i]);
		InOrderSearchBinaryTree(tree);
		printf("\n");
	}
}

int main()
{
	testSearchBinaryTree();
	testSearchBinaryTreeR();
	return 0;
}