二叉排序树binary_sort_tree
2011-12-24 14:29
344 查看
当你希望获取快速的查找时间,快速的插入删除时间,并且遍历是有序的 数据结构, 你需要的就是二叉排序树了。
AVL二叉平衡树,红黑树都是binary sort tree, 这就是STL中的map为什么(中序)遍历,key是有序输出的原因!
注意: 二叉排序树,平均插入,查找O(logn), 但如果不平衡,极端情况,查找为O(n), 一棵斜树。 所以,利用平衡可以提高效率。
为了简化,仅列出一般的binary sort tree 的常用函数编码, 暂时不考虑平衡因素。主要包括:: 构建,查找,插入,删除
代码实现:C++语言:
贴彩色代码可用:http://fayaa.com/code/new/
BinarySortTree.h:
C++语言: 高亮代码由发芽网提供
/*
简化操作, 不考虑data相等情况,即所有左子树均小于根节点,所有右子树均大于跟节点
*/
#include <iostream>
typedef struct BinaryTreeNode
{
int data;
BinaryTreeNode * lchild;
BinaryTreeNode * rchild;
} BinaryTreeNode, *BinaryTree;
class BinarySortTree
{
public:
BinarySortTree();
~BinarySortTree(void);
void InsertNode(int data);
void DeleteNode(int data);
void BuildBinarySortTree(int * data_array, int size);
bool Find(int data);
// 中序遍历打印
void PrintTree(void);
private:
void InsertNode(BinaryTree & root, int data);
void DeleteNode(BinaryTree & node);
void DeleteNode(BinaryTree & root, int data);
bool Find(BinaryTree root, int data);
void PrintTree(BinaryTree root);
void ClearTree(BinaryTree root);
BinaryTree root_;
};
BinarySortTree.cpp:
C++语言: 高亮代码由发芽网提供
#include "BinarySortTree.h"
using namespace std;
BinarySortTree::BinarySortTree(): root_(NULL)
{
}
BinarySortTree::~BinarySortTree(void)
{
ClearTree(root_);
}
void BinarySortTree::BuildBinarySortTree(int * data_array, int size)
{
for (int i=0; i<size; ++i)
{
int data = data_array[i];
InsertNode(root_, data);
}
}
void BinarySortTree::InsertNode(int data)
{
InsertNode(root_, data);
}
// 必须传引用,否则不能链接新节点。
void BinarySortTree::InsertNode(BinaryTree & root, int data)
{
BinaryTreeNode * key = root;
BinaryTreeNode * parent = key;
// 递归可以很容易实现,非递归效率更高
while (key != NULL)
{
parent = key;
if (data < key->data)
{
key = key->lchild;
}
else if (data > key->data)
{
key = key->rchild;
}
else
{ // 已有data,不再插入
return;
}
}
// key == NULL, 创建节点
key = new BinaryTreeNode();
key->data = data;
key->lchild = NULL;
key->rchild = NULL;
// 将新创建的节点,连入树中
if (parent != NULL)
{
if (data < parent->data)
{
parent->lchild = key;
}
else if (data > parent->data)
{
parent->rchild = key;
}
}
else
{
// 传引用的原因!!
root = key;
}
}
void BinarySortTree::DeleteNode(int data)
{
DeleteNode(root_, data);
}
void BinarySortTree::DeleteNode(BinaryTree & root, int data)
{
if (root == NULL)
{
cout << "Delete operation CANNOT find "<< data << " in this binary sort tree" << endl;
return;
}
if (data < root->data)
{
DeleteNode(root->lchild, data);
}
else if (data > root->data)
{
DeleteNode(root->rchild, data);
}
else // find data
{
DeleteNode(root);
}
}
void BinarySortTree::DeleteNode(BinaryTree & node)
{
if (node == NULL)
{// shoulde come here
cout <<"SHOULD NOT deleting a null Node!! " << endl;
return;
}
BinaryTreeNode * delete_node = node;
if (node->rchild == NULL)
{// 如果只有左子树,直接删除节点,并将左子树挂接到父节点
node = node->lchild;
delete delete_node;
}
else if (node->lchild == NULL)
{// 如果只有右子树,直接删除节点,并将右子树挂接到父节点
node = node->rchild;
delete delete_node;
}
else
{// 如果左右子树均存在,找直接前驱,替换节点
BinaryTreeNode * delete_node_parent = node;
delete_node = node->lchild;
while (delete_node->rchild != NULL)
{
delete_node_parent = delete_node;
delete_node = delete_node->rchild;
}
node->data = delete_node->data;// 完成节点交换
// 重新建立节点的链接
if (delete_node_parent->rchild == delete_node)
{
delete_node_parent->rchild = delete_node->lchild;
}
else
{
delete_node_parent->lchild = delete_node->lchild;
}
delete delete_node;
}
}
bool BinarySortTree::Find(int data)
{
return Find(root_, data);
}
bool BinarySortTree::Find(BinaryTree root, int data)
{
if (root == NULL)
{
return false;
}
if (data == root->data)
{
return true;
}
else if (data < root->data)
{
Find(root->lchild, data);
}
else if (data > root->data)
{
Find(root->rchild, data);
}
}
void BinarySortTree::PrintTree(void)
{
PrintTree(root_);
cout << endl;
}
void BinarySortTree::PrintTree(BinaryTree root)
{
if (root_ == NULL)
{
cout<<"This is an empty tree!" << endl;
return;
}
if (root == NULL)
{
return;
}
BinaryTreeNode * p_node = root;
// 递归实现中序遍历, 也可以借用栈非递归实现
PrintTree(p_node->lchild);
cout << p_node->data << "\t";
PrintTree(p_node->rchild);
}
void BinarySortTree::ClearTree(BinaryTree root)
{
if (root == NULL)
{
return;
}
if (root->lchild != NULL)
{
ClearTree(root->lchild);
}
if (root->rchild != NULL)
{
ClearTree(root->rchild);
}
// 删除节点
delete root;
}
main.cpp 测试代码:
C++语言: 高亮代码由发芽网提供
#include <iostream>
#include "BinarySortTree.h"
int main(int argc, const char ** argv)
{
int test_array[] = {62, 88, 58, 47, 35, 73, 51, 99, 37, 93};
int arr_size = sizeof(test_array)/sizeof(int);
BinarySortTree tree;
tree.BuildBinarySortTree(test_array, arr_size);
tree.PrintTree();
if (tree.Find(35))
{
tree.DeleteNode(35);
}
if (tree.Find(62))
{
tree.DeleteNode(62);
}
if (tree.Find(87))
{
tree.DeleteNode(87);
}
if (tree.Find(35))
{
tree.DeleteNode(37);
}
tree.PrintTree();
tree.DeleteNode(189);
return 0;
}
运行结果:
AVL二叉平衡树,红黑树都是binary sort tree, 这就是STL中的map为什么(中序)遍历,key是有序输出的原因!
注意: 二叉排序树,平均插入,查找O(logn), 但如果不平衡,极端情况,查找为O(n), 一棵斜树。 所以,利用平衡可以提高效率。
为了简化,仅列出一般的binary sort tree 的常用函数编码, 暂时不考虑平衡因素。主要包括:: 构建,查找,插入,删除
代码实现:C++语言:
贴彩色代码可用:http://fayaa.com/code/new/
BinarySortTree.h:
C++语言: 高亮代码由发芽网提供
/*
简化操作, 不考虑data相等情况,即所有左子树均小于根节点,所有右子树均大于跟节点
*/
#include <iostream>
typedef struct BinaryTreeNode
{
int data;
BinaryTreeNode * lchild;
BinaryTreeNode * rchild;
} BinaryTreeNode, *BinaryTree;
class BinarySortTree
{
public:
BinarySortTree();
~BinarySortTree(void);
void InsertNode(int data);
void DeleteNode(int data);
void BuildBinarySortTree(int * data_array, int size);
bool Find(int data);
// 中序遍历打印
void PrintTree(void);
private:
void InsertNode(BinaryTree & root, int data);
void DeleteNode(BinaryTree & node);
void DeleteNode(BinaryTree & root, int data);
bool Find(BinaryTree root, int data);
void PrintTree(BinaryTree root);
void ClearTree(BinaryTree root);
BinaryTree root_;
};
BinarySortTree.cpp:
C++语言: 高亮代码由发芽网提供
#include "BinarySortTree.h"
using namespace std;
BinarySortTree::BinarySortTree(): root_(NULL)
{
}
BinarySortTree::~BinarySortTree(void)
{
ClearTree(root_);
}
void BinarySortTree::BuildBinarySortTree(int * data_array, int size)
{
for (int i=0; i<size; ++i)
{
int data = data_array[i];
InsertNode(root_, data);
}
}
void BinarySortTree::InsertNode(int data)
{
InsertNode(root_, data);
}
// 必须传引用,否则不能链接新节点。
void BinarySortTree::InsertNode(BinaryTree & root, int data)
{
BinaryTreeNode * key = root;
BinaryTreeNode * parent = key;
// 递归可以很容易实现,非递归效率更高
while (key != NULL)
{
parent = key;
if (data < key->data)
{
key = key->lchild;
}
else if (data > key->data)
{
key = key->rchild;
}
else
{ // 已有data,不再插入
return;
}
}
// key == NULL, 创建节点
key = new BinaryTreeNode();
key->data = data;
key->lchild = NULL;
key->rchild = NULL;
// 将新创建的节点,连入树中
if (parent != NULL)
{
if (data < parent->data)
{
parent->lchild = key;
}
else if (data > parent->data)
{
parent->rchild = key;
}
}
else
{
// 传引用的原因!!
root = key;
}
}
void BinarySortTree::DeleteNode(int data)
{
DeleteNode(root_, data);
}
void BinarySortTree::DeleteNode(BinaryTree & root, int data)
{
if (root == NULL)
{
cout << "Delete operation CANNOT find "<< data << " in this binary sort tree" << endl;
return;
}
if (data < root->data)
{
DeleteNode(root->lchild, data);
}
else if (data > root->data)
{
DeleteNode(root->rchild, data);
}
else // find data
{
DeleteNode(root);
}
}
void BinarySortTree::DeleteNode(BinaryTree & node)
{
if (node == NULL)
{// shoulde come here
cout <<"SHOULD NOT deleting a null Node!! " << endl;
return;
}
BinaryTreeNode * delete_node = node;
if (node->rchild == NULL)
{// 如果只有左子树,直接删除节点,并将左子树挂接到父节点
node = node->lchild;
delete delete_node;
}
else if (node->lchild == NULL)
{// 如果只有右子树,直接删除节点,并将右子树挂接到父节点
node = node->rchild;
delete delete_node;
}
else
{// 如果左右子树均存在,找直接前驱,替换节点
BinaryTreeNode * delete_node_parent = node;
delete_node = node->lchild;
while (delete_node->rchild != NULL)
{
delete_node_parent = delete_node;
delete_node = delete_node->rchild;
}
node->data = delete_node->data;// 完成节点交换
// 重新建立节点的链接
if (delete_node_parent->rchild == delete_node)
{
delete_node_parent->rchild = delete_node->lchild;
}
else
{
delete_node_parent->lchild = delete_node->lchild;
}
delete delete_node;
}
}
bool BinarySortTree::Find(int data)
{
return Find(root_, data);
}
bool BinarySortTree::Find(BinaryTree root, int data)
{
if (root == NULL)
{
return false;
}
if (data == root->data)
{
return true;
}
else if (data < root->data)
{
Find(root->lchild, data);
}
else if (data > root->data)
{
Find(root->rchild, data);
}
}
void BinarySortTree::PrintTree(void)
{
PrintTree(root_);
cout << endl;
}
void BinarySortTree::PrintTree(BinaryTree root)
{
if (root_ == NULL)
{
cout<<"This is an empty tree!" << endl;
return;
}
if (root == NULL)
{
return;
}
BinaryTreeNode * p_node = root;
// 递归实现中序遍历, 也可以借用栈非递归实现
PrintTree(p_node->lchild);
cout << p_node->data << "\t";
PrintTree(p_node->rchild);
}
void BinarySortTree::ClearTree(BinaryTree root)
{
if (root == NULL)
{
return;
}
if (root->lchild != NULL)
{
ClearTree(root->lchild);
}
if (root->rchild != NULL)
{
ClearTree(root->rchild);
}
// 删除节点
delete root;
}
main.cpp 测试代码:
C++语言: 高亮代码由发芽网提供
#include <iostream>
#include "BinarySortTree.h"
int main(int argc, const char ** argv)
{
int test_array[] = {62, 88, 58, 47, 35, 73, 51, 99, 37, 93};
int arr_size = sizeof(test_array)/sizeof(int);
BinarySortTree tree;
tree.BuildBinarySortTree(test_array, arr_size);
tree.PrintTree();
if (tree.Find(35))
{
tree.DeleteNode(35);
}
if (tree.Find(62))
{
tree.DeleteNode(62);
}
if (tree.Find(87))
{
tree.DeleteNode(87);
}
if (tree.Find(35))
{
tree.DeleteNode(37);
}
tree.PrintTree();
tree.DeleteNode(189);
return 0;
}
运行结果:
相关文章推荐
- 二叉排序树(Binary Sort Tree)查找、插入、删除 Java实现
- 二叉排序树(Binary Sort Tree)
- 二叉排序树(Binary Sort Tree)的查找递归算法
- 二叉排序树(BinarySortTree)的实现
- 二叉排序树binary_sort_tree
- 二叉排序树_BinarySortTree
- 二叉排序树(Binary Sort Tree)
- 二叉排序树(Binary Sort Tree)
- 二叉排序树(Binary Sort Tree,二叉查找树,二叉搜索树)--【算法导论】
- 【数据结构】二叉排序树_BinarySortTree
- 大话数据结构 code 第八章 02二叉排序树_BinarySortTree
- [数据结构]程杰—— 二叉排序树_BinarySortTree
- 二叉排序树(Binary Sort Tree)
- 二叉排序树BinarySortTree(二叉搜索树Binary Search Tree)
- 二叉排序树(Binary Sort Tree)
- BinarySortTree二叉排序树(2010年12月07日)
- 算法学习记录-查找——二叉排序树(Binary Sort Tree)
- 数据结构之---C语言实现二叉排序树(BinarySortTree)
- 【LeetCode】108. Convert Sorted Array to Binary Search Tree-有序数组转换为平衡二叉搜索树(平衡二叉排序树)
- 【LeetCode】98. Validate Binary Search Tree -判断是否为二叉排序树