《数据结构与算法分析 c语言描述》4章二叉树代码~模板

书上的二叉查找树基本代码。

用模板实现了。模板函数的声明和定义分别放在.h和.cpp文件中，编译时会报链接错误，只能在同时放在头文件中。至于为什么，没太搞清楚，代码如下：

#pragma once
#include <iostream>
template <typename T>
struct TREE_NODE{
	T value;
	TREE_NODE* left;
	TREE_NODE* right;
	struct TREE_NODE()
	{
		memset(this,0,sizeof(struct TREE_NODE));
		left = NULL;
		right = NULL;
	}
};

template <typename T>
class SearchTree
{
public:
	SearchTree(void);
	~SearchTree(void);
	void insert(T t);
	void deleteEle(T t);
	TREE_NODE<T>* find(T value);
	TREE_NODE<T>* findMin();
	TREE_NODE<T>* findMax();
	void MakeEmpty(struct TREE_NODE<T> *p);
	//mode:0:前序；1：中序；2：后序
	void print(int mode);
private:
	void preOrder(); 
	void inOrder(); 
	void postOrder(); 

	TREE_NODE<T> * _insert(T t,struct TREE_NODE<T> *pRoot);
	void _preOrder(struct TREE_NODE<T> *pRoot); 
	void _inOrder(struct TREE_NODE<T> *pRoot); 
	void _postOrder(struct TREE_NODE<T> *pRoot); 
	TREE_NODE<T>* _findMin(struct TREE_NODE<T> *pRoot);
	TREE_NODE<T>* _findMax(struct TREE_NODE<T> *pRoot);
	struct TREE_NODE<T> * _deleteEle(T t,struct TREE_NODE<T> *pRoot);
	struct TREE_NODE<T> *m_pRoot;
};

template <typename T>
SearchTree<T>::SearchTree(void)
{
	m_pRoot = NULL;
}

template <typename T>
SearchTree<T>::~SearchTree(void)
{
	MakeEmpty(m_pRoot);
}
template <typename T>
void SearchTree<T>::insert(T t)
{
	if (m_pRoot)
	{
		_insert(t,m_pRoot);
	}else if(m_pRoot == NULL)
	{
		m_pRoot = new struct TREE_NODE<T>;	
		m_pRoot->value = t;
	}	
}

template <typename T>
void SearchTree<T>::deleteEle(T t)
{
	_deleteEle(t,m_pRoot);
}

template <typename T>
TREE_NODE<T>* SearchTree<T>::find(T value)
{
	TREE_NODE<T>* pRet = NULL;
	return pRet;
}

template <typename T>
TREE_NODE<T>* SearchTree<T>::findMin()
{
	TREE_NODE<T>* pRet = NULL;
	pRet = _findMin(m_pRoot);

	return pRet;
}

template <typename T>
TREE_NODE<T>* SearchTree<T>::findMax()
{
	TREE_NODE<T>* pRet = NULL;
	return pRet;
}

template <typename T>
void SearchTree<T>::MakeEmpty(struct TREE_NODE<T> *p)
{
	if (p)
	{
		MakeEmpty(p->left);
		MakeEmpty(p->right);
		delete p;
	}
}

template <typename T>
void SearchTree<T>::preOrder() 
{
	_preOrder(m_pRoot);
}

template <typename T>
void SearchTree<T>::inOrder()
{
	_inOrder(m_pRoot);
}

template <typename T>
void SearchTree<T>::postOrder()
{
	_postOrder(m_pRoot);
}

template <typename T>
void SearchTree<T>::print(int mode)
{
	printf("\n================\n");
	switch (mode)
	{
	case 0:
		preOrder();break;
	case 1:
		inOrder();break;
	case 2:
		postOrder();break;
	default:
		break;
	}
}

template <typename T>
TREE_NODE<T> * SearchTree<T>::_insert(T t,struct TREE_NODE<T> *pRoot)
{
	if (pRoot == NULL)
	{
		pRoot = new struct TREE_NODE<T>;
		memset(pRoot,0,sizeof(struct TREE_NODE<T>));
		pRoot->left = NULL;
		pRoot->right = NULL;
		pRoot->value = t;
	}else if (t<pRoot->value)
	{
		pRoot->left = _insert(t,pRoot->left);
	}else if(t>pRoot->value)
	{
		pRoot->right = _insert(t,pRoot->right);
	}
	return pRoot;
}

template <typename T>
void SearchTree<T>::_preOrder(struct TREE_NODE<T> *pRoot)
{
	if (pRoot == NULL)
	{
		return;
	}else{		
		std::cout<<pRoot->value<<"   ";
		_preOrder(pRoot->left);
		_preOrder(pRoot->right);
	}
}

template <typename T>
void SearchTree<T>::_inOrder(struct TREE_NODE<T> *pRoot)
{
	if (pRoot == NULL)
	{
		return;
	}else
	{
		_inOrder(pRoot->left);	
		std::cout<<pRoot->value<<"  ";
		_inOrder(pRoot->right);
	}
}

template <typename T>
void SearchTree<T>::_postOrder(struct TREE_NODE<T> *pRoot)
{
	if (pRoot == NULL)
	{
		return;
	}else
	{
		_postOrder(pRoot->left);
		_postOrder(pRoot->right);
		std::cout<<pRoot->value<<"  ";		
	}
}

template <typename T>
TREE_NODE<T>* SearchTree<T>::_findMin(struct TREE_NODE<T> *pRoot)
{
	if (pRoot)
	{
		if (pRoot->left)
		{
			pRoot = _findMin(pRoot->left);
		}
	}
	return pRoot;
}

template <typename T>
TREE_NODE<T>* SearchTree<T>::_findMax(struct TREE_NODE<T> *pRoot)
{
	if (pRoot)
	{
		if (pRoot->right != NULL)
		{
			pRoot = _findMax(pRoot->right);
		}
	}
	return pRoot;
}
template <typename T>
TREE_NODE<T>* SearchTree<T>::_deleteEle(T t,struct TREE_NODE<T> *pRoot)
{
	if (!pRoot)
	{
		return NULL;
	}

	if (t > pRoot->value)
	{
		pRoot->right =  _deleteEle(t,pRoot->right);//返回根节点
	}else if (t<pRoot->value)
	{
		pRoot->left = _deleteEle(t,pRoot->left);
	}else
	{
		//删除当前节点
		if (pRoot->left &&pRoot->right)
		{
			struct TREE_NODE<T> *p = NULL;
			p = _findMin(pRoot->right);
			pRoot->value = p->value;
			pRoot->right = _deleteEle(p->value,pRoot->right);
		}else{
			//单孩子节点或叶子节点
			struct TREE_NODE<T> *p = NULL;
			if (pRoot->left == NULL)
			{
				pRoot = pRoot->right;
			}else if (pRoot->right == NULL)
			{
				pRoot = pRoot->left;
			}
			delete p;		
		}
	}
	return pRoot;	
}

测试代码如下：

#include <iostream>
#include <string>

#include "SearchTree.h"

int main()
{	
	SearchTree<std::string> tree1;
	tree1.insert("lxx");
	tree1.insert("awx");
	tree1.insert("mqq");
	tree1.insert("slamdunk");
	tree1.insert("ma");
	tree1.print(0);
	tree1.print(1);
	tree1.print(2);

	tree1.deleteEle("lxx");
	tree1.print(0);
	tree1.print(1);
	tree1.print(2);

	return 0;
}

建立的二叉树：

删除节点后的树：

打印结果如下：