二叉查找树的C语言实现

一：二叉树

二叉树是一颗树，其中么个节点的儿子数目都不能超过俩个。

二叉树的实现：

因为一颗二叉树最多有俩个儿子，所以我们可以用指针直接指向他们。

这种定义和链表定义相同：

Typedef struct TreeNode *ptrToNode;

Typedef struct ptrToNode Tree;

Struct TreeNode

{

ElementType Element;

Tree left;

Tree right;

};

二叉树的主要用处之一实在编译器的设计领域。用来存储一个表达式。

 

读出时要用特定的顺序来读，一般是中序遍历，即左-根-右。相应的还有先序遍历：

根-左-右，后序遍历：左-右-根。这里的先后是相对于根节点来说的。

 

二：二叉查找树

二叉树的一个重要的应用是它们在查找中的使用。

使二叉树成为二叉查找树的性质是：对于树的每个节点X，它的左子树中所有关键字的值小于X的关键字值，右子树中所有关键字值大于X的关键字值。这表示该树的所有元素可以用某种统一的方式排序。

C语言实现：

实现文件：

#include "erChaSearchTree.h"

/*置空*/
searchTree makeEmpty(searchTree Tree)
{
	if(Tree!=NULL)
	{
		makeEmpty(Tree->left);
		makeEmpty(Tree->right);
		free(Tree);
	}
	return NULL;

}

/*查找数据*/
position find(ElementType element,searchTree Tree)
{
	if(Tree==NULL)
		return NULL;

	if(Tree->element==element)
		return Tree;
	else if(Tree->element<element)
		find(element,Tree->right);
	else 
		find(element,Tree->left);

}

/*查找最小值*/
position findMin(searchTree Tree)
{
	if(Tree==NULL)
		return NULL;
	else if(Tree->left==NULL)
		return Tree;
	else
		return findMin(Tree->left);		//根据二叉查找树的原理，最左边的叶子是最小的

}

/*查找最大值 非递归实现*/
position findMax(searchTree Tree)
{
	if(Tree!=NULL)
		while(Tree->right!=NULL)
			Tree=Tree->right;
		return Tree;
}
/*插入数据*/

searchTree insert(ElementType element,searchTree Tree)
{
	if(Tree==NULL)
	{
		Tree=(struct TreeNode*)malloc(sizeof(struct TreeNode));
		if(Tree==NULL)
		{
			printf("out of space\n");
			exit(-1);
		}
		Tree->element=element;
		Tree->left=Tree->right=NULL;
	}
	else
	{
		if(element<Tree->element)
			Tree->left=insert(element,Tree->left);
		else if(element>Tree->element)
			Tree->right=insert(element,Tree->right);
		else
			printf("already exist\n");
	}
	return Tree;

}
/*删除数据*/
searchTree deleteElement(ElementType element,searchTree Tree)
{
	struct TreeNode* tmpcell;
	if(Tree==NULL)
	{
		printf("cant delete a emptytree\n");
		exit(-1);
	}
	else
	{
		if(element<Tree->element)
			Tree->left=deleteElement(element,Tree->left);
		else if(element>Tree->element)
			Tree->right=deleteElement(element,Tree->right);
		else
		{
			if(Tree->left&&Tree->right)	//俩个儿子
			{
				tmpcell=findMin(Tree->right);
				Tree->element=tmpcell->element;
				Tree->right=deleteElement(tmpcell->element,Tree->right);
			}	
			else		//最多一个儿子
			{
				tmpcell=Tree;
				if(Tree->left==NULL)
					Tree=Tree->right;
				else if(Tree->right==NULL)
					Tree=Tree->left;
				free(tmpcell);
			}
		}
	}
	return Tree;
}

void preOrderTraverse(searchTree Tree)
{
	if(Tree)
	{
		printf(" %d ",Tree->element);
		preOrderTraverse(Tree->left);
		preOrderTraverse(Tree->right);
	}

}	
void inOrderTraverse(searchTree Tree)	
{
	if(Tree)
	{
		inOrderTraverse(Tree->left);
		printf(" %d ",Tree->element);
		inOrderTraverse(Tree->right);
	}
}
void houxu(searchTree Tree)	
{
if(Tree)
	{
		houxu(Tree->left);
		houxu(Tree->right);
		printf(" %d ",Tree->element);
	}
}

头文件

#ifndef __ERCHASEARCHTREE_H
#define __ERCHASEARCHTREE_H

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


struct TreeNode;
typedef struct TreeNode* position;
typedef struct TreeNode* searchTree;
typedef int ElementType;
struct TreeNode
{
	ElementType element;
	searchTree left;
	searchTree right;
};


/*置空*/
searchTree makeEmpty(searchTree Tree);
/*查找数据*/
position find(ElementType element,searchTree Tree);
/*查找最小值*/
position findMin(searchTree Tree);
/*查找最大值*/
position findMax(searchTree Tree);
/*插入数据*/
searchTree insert(ElementType element,searchTree Tree);
/*删除数据*/
searchTree deleteElement(ElementType element,searchTree Tree);

/*遍历二叉树*/
void preOrderTraverse(searchTree Tree);	//先序遍历 根左右
void inOrderTraverse(searchTree Tree);	//中序遍历 左根右
void houxu(searchTree Tree);	//后序遍历 左右根

#endif

测试文件

#include "erChaSearchTree.h"
#include <stdio.h>

int main()
{
	/******************二叉查找树测试****************************/
	/*position pos;
	searchTree root=NULL;
	root=insert(6,root);
	insert(2,root);
	insert(1,root);
	insert(4,root);
	insert(3,root);
	insert(8,root);
	preOrderTraverse(root);
	printf("\n");

	pos=find(8,root);
	printf("find %d\n",pos->element);
	pos=findMax(root);
	printf("max= %d\n",pos->element);
	pos=findMin(root);
	printf("min= %d\n",pos->element);

	deleteElement(2,root);
	preOrderTraverse(root);
	printf("\n");
	inOrderTraverse(root);
	printf("\n");
	houxu(root);
	printf("\n");
	makeEmpty(root);*/
	/**********************************************/
}