參考了Weiss的資料結構與演算法分析C++描述第三版

在中文版中，第99頁貌似有個錯誤。在4.3.6 平均情況分析中，書上寫的是“直觀地，我們期望前一節所有的操作特別是makeEmpty 和 operator=都花費O(logN)時間，……”，我感覺不太對，因為makeEmpty 和 operator=都遍歷了每個節點，花費應該是O(N)才對，其他的操作，比如查詢元素，查詢最大最小之類的，應該是O(logN)。然後我找了一下英文原版書，是第四版了，原文是“Intuitively, we expect that all of the operations described in this section, except

下面記錄一下今天的程式碼

首先是定義了二叉查詢樹的模板：BinarySearchTree.h

#ifndef BINARY_SEARCH_TREE_H
#define BINARY_SEARCH_TREE_H
#include<iostream>
using namespace std;

template <typename Comparable>
class BinarySearchTree
{
public:
	BinarySearchTree() :m_root(nullptr){}
	BinarySearchTree(const BinarySearchTree &rhs)
	{
		m_root = clone(rhs.m_root);
	}
	~BinarySearchTree()
	{
		makeEmpty();
	}

	/**
	* 找到樹中的最小值，通過呼叫private的findMin實現遞迴
	*/
	const Comparable & findMin() const
	{
		return findMin(m_root)->element;
	}

	/**
	* 找到樹中的最大值，通過呼叫private的findMax實現遞迴
	*/
	const Comparable & findMax() const
	{
		return findMax(m_root)->element;
	}

	/**
	* 當x找到時返回真，否則返回假 
	* 呼叫了private的那個同名函式，這個是為了遞迴實現
	*（因為private中包含了一個BinaryNode的指標t）
	*/
	bool contains(const Comparable &x) const
	{
		return contains(x, m_root);
	}

	/**
	* 判斷樹是否為空
	*/
	bool isEmpty() const
	{
		return m_root == nullptr;
	}

	/**
	* 把樹遍歷一遍（中序,因為中序可以保證順序輸出）
	*/
	void printTree(ostream & out= cout) const
	{
		if (isEmpty())
			out << "Empty tree!" << endl;
		else
			printTree(m_root, out);
	}

	/**
	* 清空樹
	*/
	void makeEmpty()
	{
		makeEmpty(m_root);
	}

	/**
	* 把x插入樹中，如果重複了就忽略
	*/
	void insert(const Comparable &x)
	{
		insert(x, m_root);
	}

	/**
	* 把x從樹中刪除。如果x不在樹中就什麼都不做。
	*/
	void remove(const Comparable &x)
	{
		remove(x, m_root);
	}

	/**
	* 深拷貝
	*/
	const BinarySearchTree & operator= (const BinarySearchTree &rhs)
	{
		if (this != &rhs)
		{
			BinaryNode *tmp = clone(rhs.m_root);
			makeEmpty();
			m_root = tmp;
		}
		return *this;
	}


private:
	struct BinaryNode{
		Comparable element;
		BinaryNode *left;
		BinaryNode *right;
		
		BinaryNode(const Comparable &theElement,
			BinaryNode *lt,
			BinaryNode *rt)
			: element(theElement), left(lt), right(rt) {}
	};

	BinaryNode *m_root;

	/**
	* 在樹t中插入元素x，如果重複則什麼也不做
	*/
	void insert(const Comparable &x, BinaryNode * &t) const
	{
		if (t == nullptr)
			t = new BinaryNode(x, nullptr, nullptr);
		else if (x < t->element)
			insert(x, t->left);
		else if (t->element < x)
			insert(x, t->right);
		else
			; // 表示在樹中找到了x，則什麼也不做
	}

	/**
	* 在樹t中刪除元素x
	*/
	void remove(const Comparable &x, BinaryNode * &t) const
	{
		if (t == nullptr)
			return; // 沒有找要刪除的節點x
		if (x < t->element)
			remove(x, t->left);
		else if (t->element < x)
			remove(x, t->right);
		else if (t->left != nullptr &&
		t->right != nullptr)
		{
			t->element = findMin(t->right)->element;
			remove(t->element, t->right);
		}
		else
		{
			BinaryNode * oldNode = t;
			t = (t->left != nullptr) ? t->left : t->right;
			delete oldNode;
		}
	}

	/**
	* 查詢最小的元素, 通過遞迴的方法
	*/
	BinaryNode * findMin(BinaryNode *t) const
	{
		if (t == nullptr)
			return nullptr;
		if (t->left == nullptr)
			return t;
		return findMin(t->left);
	}

	/**
	* 查詢最大的元素, 通過迴圈的方法
	*/
	BinaryNode * findMax(BinaryNode *t) const
	{
		if (t != nullptr)
			while (t->right != nullptr)
				t = t->right;
		return t;
	}

	/**
	* 通過遍歷的方法查詢x是否在樹（或子樹）t中
	*/
	bool contains(const Comparable &x, BinaryNode * t) const
	{
		if (t == nullptr) // 遍歷中未找到元素的中止條件
			return false;
		else if (x < t->element)
			return contains(x, t->left);
		else if (t->element < x)
			return contains(x, t->right);
		else // 如果 x 不大於 也 不小於t所指的節點中的元素，則x==t->element
			return true;
	}

	/**
	* 清空樹
	*/
	void makeEmpty(BinaryNode * &t)
	{
		if (t != nullptr)
		{
			makeEmpty(t->left);
			makeEmpty(t->right);
			delete t;
		}
		t = nullptr;
	}

	/**
	* 列印子樹
	*/
	void printTree(BinaryNode *t, ostream & out) const
	{
		if (nullptr != t)
		{
			printTree(t->left, out);
			out << t->element << endl;
			printTree(t->right, out);
		}
	}

	/**
	* 複製子樹
	*/
	BinaryNode * clone(BinaryNode *t) const
	{
		if (t == nullptr)
			return nullptr;

		return new BinaryNode(t->element, clone(t->left), clone(t->right));
	}

};
#endif
 

#include<iostream>
#include<random>
#include<ctime>
using namespace std;

#include"BinarySearchTree.h"

int main()
{
	BinarySearchTree<int> t; // 建立一個二叉搜尋樹

	uniform_int_distribution<unsigned int> u(0,200); // 設定隨機數分佈
	default_random_engine e(time(0)); // 設定隨機數引擎（通過時間作為種子）

	cout << "==== 測試插入：" << endl;
	for (size_t i = 0; i < 8; ++i)
	{
		t.insert(u(e));
	}
	cout << "==== 測試列印："<< endl;
	t.printTree();
	cout << "==== 測設刪除（刪除小於100的數）：" << endl;
	for (size_t i = 0; i < 100; ++i)
	{
		t.remove(i);
	}
	t.printTree();
	cout << "==== 測試拷貝建構函式：" << endl;
	BinarySearchTree<int> t2(t);
	t2.printTree();
	cout << "==== 測試賦值操作：" << endl;
	BinarySearchTree<int> t3;
	t3 = t;
	t.printTree();
	cout << "==== 測試最大最小值：" << endl;
	cout << "最大值：" << t.findMax() << endl;
	cout << "最小值：" << t.findMin() << endl;

	return 0;
}