二叉搜索樹（算法導論）

#include <iostream>
using namespace std;

struct tree_node // 樹節點
{
	tree_node(int x) : data(x), lchild(nullptr), rchild(nullptr), parent(nullptr){}

	int data;
	tree_node *lchild;
	tree_node *rchild;
	tree_node *parent;
};

class binaryTree // 二叉搜索樹
{
public:
	binaryTree() : root(nullptr){}

public:
	void inorder_tree_walk(tree_node *x); // 中序遍歷（遞歸） 
	void preorder_tree_walk(tree_node *x); // 前序遍歷（遞歸）
	void postorder_tree_walk(tree_node *x); // 後序遍歷（遞歸）

	tree_node *tree_search(tree_node *x, int key); // 查找（遞歸）
	tree_node *iterative_tree_search(tree_node *x, int key); // 查找（非遞歸）
	tree_node *tree_minimum(tree_node *x); // 查找最小值
 	tree_node *tree_maximum(tree_node *x); // 查找最大值
	tree_node *tree_successor(tree_node *x); // 查找後繼
	tree_node *tree_predecessor(tree_node *x); // 查找前驅

	void tree_insert(tree_node *z); // 插入（非遞歸）
	tree_node *tree_delete(tree_node *z); // 刪除（非遞歸）

	tree_node *root; // 指向根的指針
};

void binaryTree::inorder_tree_walk(tree_node *x)
{
	if (x != nullptr)
	{
		inorder_tree_walk(x->lchild);
		cout << x->data << " ";
		inorder_tree_walk(x->rchild);
	}
}

void binaryTree::preorder_tree_walk(tree_node *x)
{
	if (x != nullptr)
	{
		cout << x->data << " ";
		preorder_tree_walk(x->lchild);
		preorder_tree_walk(x->rchild);
	}
}

void binaryTree::postorder_tree_walk(tree_node *x)
{
	if (x != nullptr)
	{
		postorder_tree_walk(x->lchild);
		postorder_tree_walk(x->rchild);
		cout << x->data << " ";
	}
}

tree_node *binaryTree::tree_search(tree_node *x, int key) // x應爲指向根節點的指針
{
	if (x == nullptr || x->data == key)
	{
		return x;
	}

	if (key < x->data)
	{
		return tree_search(x->lchild, key);
	}
	else
	{
		return tree_search(x->rchild, key);
	}
}

tree_node *binaryTree::iterative_tree_search(tree_node *x, int key) // 找到返回指向key的指針 找不到 返回nullptr
{
	while (x != nullptr && x->data != key)
	{
		if (key < x->data)
		{
			x = x->lchild;
		}
		else
		{
			x = x->rchild;
		}
	}
	return x;
}

tree_node *binaryTree::tree_minimum(tree_node *x)
{
	while (x->lchild != nullptr)
	{
		x = x->lchild;
	}
	return x;
}

tree_node *binaryTree::tree_maximum(tree_node *x)
{
	while (x->rchild != nullptr)
	{
		x = x->rchild;
	}
	return x;
}

tree_node *binaryTree::tree_successor(tree_node *x)
{
	if (x->rchild != nullptr)
	{
		return tree_minimum(x->rchild);
	}

	tree_node *y = x->parent;

	while (y != nullptr && y->rchild == x)
	{
		x = y;
		y = y->parent;
	}
	return y;
}

tree_node *binaryTree::tree_predecessor(tree_node *x)
{
	if (x->lchild != nullptr)
	{
		return tree_maximum(x->lchild);
	}

	tree_node *y = x->parent;

	while (y != nullptr && y->lchild == x)
	{
		x = y;
		y = x->parent;
	}
	return y;
}

void binaryTree::tree_insert(tree_node *z) 
{
	tree_node *x = root; tree_node *y = nullptr; // 用x記錄一條向下的路徑
												// y通過循環保存要被插入的元素位置	
	while (x != nullptr)
	{
		y = x;
		if (z->data < x->data)
		{
			x = x->lchild;
		}
		else if (z->data > x->data)
		{
			x = x->rchild;
		}
		else
		{
			cout << "error : exist" << endl;
			return;
		}
	}
	z->parent = y; 

	if (y == nullptr)
	{
		root = z;
	}
	else if (z->data < y->data)
	{
		y->lchild = z;
	}
	else
	{
		y->rchild = z;
	}
}

tree_node *binaryTree::tree_delete(tree_node *z) 
{
	tree_node *x, *y; // y表示“實際要刪除的結點”  x表示y的孩子

	if (z->lchild == nullptr || z->rchild == nullptr)
		y = z;	
	else
		y = tree_successor(z); // 當x有兩個孩子的時候 y是z的後繼
		
	if (y->lchild != nullptr)
		x = y->lchild;
	else
		x = y->rchild;

	if (x != nullptr)
	{
		x->parent = y->parent;
	}

	if (y->parent == nullptr)
	{
		root = x;
	}
	else if (y == y->parent->lchild)
	{
		y->parent->lchild = x;
	}
	else
	{
		y->parent->rchild = x;
	}

	if (y != z) // 把y的數據賦給z
	{
		z->data = y->data;
	}

	return y;
}

int main()
{
	binaryTree demo;

	for (int i = 0; i < 6; ++i)
	{
		demo.tree_insert(new tree_node(i));
	}

	demo.inorder_tree_walk(demo.root);
	cout << endl;
	demo.postorder_tree_walk(demo.root);
	cout << endl;
	demo.preorder_tree_walk(demo.root);
	cout << endl;

	cout << (demo.tree_maximum(demo.root))->data << endl;
	cout << (demo.tree_minimum(demo.root))->data << endl;

	cout << (demo.iterative_tree_search(demo.root, 1)) << endl << (demo.iterative_tree_search(demo.root, 1))->data << endl;

	cout << (demo.tree_successor(demo.root))->data << endl;
	cout << (demo.tree_predecessor((demo.root)->rchild))->data << endl;

	demo.tree_delete(demo.root);

	demo.inorder_tree_walk(demo.root);

	return 0;
}