二叉搜索树实现与测试

原创 2007年09月27日 01:14:00
/**//******************************************
 * 文件名:BSTree.cpp
 * 功能:1,定义二叉查找树结点
        2,定义二叉查找树
        3,测试二叉查找树
*****************************************
*/

#include 
<iostream>
using namespace std;

template 
<typename T>
class BSTnode
...{
public:
    BSTnode():pare(
0),left(0),right(0)
    
...{ }
    BSTnode(
const T &v, BSTnode<T> *= 0, BSTnode<T> *lef = 0, BSTnode<T> *rig = 0):value(v),pare(p),left(lef),right(rig)
    
...{ }

public:
    T value;
    BSTnode
<T> *pare, *left, *right;
}
;

// 以上是二叉查找树结点的定义
// 以下是二叉查找树的定义

template 
<typename T>
class BSTree
...{
public:
    BSTnode
<T> *root;

public:
    BSTree():root(
0)
    
...{}
    BSTree(
const BSTnode<T> &r):root(&r)
    
...{}
    BSTree(
const T &v)
    
...{
        root 
= new BSTnode<T>(v);
    }


    
void Insert_BST(const T &v)
    
...{
        
if( root == 0 )
            root 
= new BSTnode<T>(v);
        
else
        
...{
            BSTnode
<T> *curr = root;
            BSTnode
<T> *= 0;

            
while(curr != 0)
            
...{
                p 
= curr;
                curr 
= (v > curr->value) ? curr->right : curr->left;
            }


            curr 
= new BSTnode<T>(v);
            curr
->pare = p;
            
if( curr->value > p->value )
                p
->right = curr;
            
else
                p
->left = curr;
        }
 // else
    }
 // Insert_BST

    BSTnode
<T> *search_BST(const T &v)
    
...{
        BSTnode
<T> *curr = root;
        
while( (curr != 0&& (v != curr->value) )
        
...{
            curr 
= (v > curr->value) ? curr->right : curr->left;
        }


        
return curr;
    }
 // search_BST

    T mini_BST(BSTnode
<T> *r) const
    
...{
        BSTnode
<T> *curr = r;
        
while( curr->left != 0 )
            curr 
= curr->left;

        
return curr->value;
    }


    T max_BST(BSTnode
<T> *r) const
    
...{
        BSTnode
<T> *curr = r;
        
while(curr->right != 0)
            curr 
= curr->right;

        
return curr->value;
    }


    T next_BST(
const T &v)
    
...{
        BSTnode
<T> *curr;
        curr 
= search_BST(v);
        
if(curr->right != 0)
            
return mini_BST(curr->right);

        BSTnode
<T> *= curr->pare;
        
while((p != 0&& (curr == p->right))
        
...{
            curr 
= p;
            p 
= p->pare;
        }


        
return p->value;
    }


    T prev_BST(
const T &v)
    
...{
        BSTnode
<T> *curr;
        curr 
= search_BST(v);
        
if(curr->left != 0)
            
return max_BST(curr->left);

        BSTnode
<T> *= curr->pare;
        
while((p != 0&& (curr == p->left))
        
...{
            curr 
= p;
            p 
= curr->pare;
        }


        
return p->value;
    }


    BSTnode
<T> *del_BST(BSTnode<T> *r, const T &v)
    
...{
        BSTnode
<T> *curr, *y, *x;
        curr 
= 0;
        y 
= 0;
        x 
= 0;

        curr 
= search_BST(v);
        
if( curr == 0 )
            
return 0;

        
if((curr->left == 0|| (curr->right == 0))
            y 
= curr;
        
else
            y 
= search_BST(next_BST(v));

        
if( y->left != 0 )
            x 
= y->left;
        
else
            x 
= y->right;

        
if(x != 0)
            x
->pare = y->pare;
        
        
if(y->pare == 0)
            r 
= x;
        
else if( y == y->pare->left )
            y
->pare->left = x;
        
else
            y
->pare->right = x;

        
if( y != curr )
            curr
->value = y->value;
    
        
return y;
    }


    
// 中序遍历BSTree 输出每个结点值
    void InOrder_BST(BSTnode<T> *r)
    
...{
        
if(r != 0)
        
...{
            InOrder_BST(r
->left);
            cout 
<< r->value << ' ';
            InOrder_BST(r
->right);
        }

    }

}
;

/**//***************************************************
                        14
                    /        
                   3        17
                  /           /  
                 2     5      15   18
                    /                 
                   4   7

**************************************************
*/

int main()
...{
    BSTree
<int> a(14);
    
    a.Insert_BST(
3);
    a.Insert_BST(
2);
    a.Insert_BST(
5);
    a.Insert_BST(
4);
    a.Insert_BST(
7);
    a.Insert_BST(
17);
    a.Insert_BST(
15);
    a.Insert_BST(
18);

    a.InOrder_BST(a.root);
    cout 
<< endl;
    
// 2 3 4 5 7 14 15 17 18

    cout 
<< a.prev_BST(5<< " <- 5 -> " << a.next_BST(5<< endl;
    
// 4 <- 5 -> 7

    cout 
<< a.search_BST(5)->value << endl;
    
// 5

    cout 
<< a.del_BST(a.root, 3)->value << endl;
    
// 7

    a.InOrder_BST(a.root);
    
// 2 3 4 7 14 15 17 18

    
return 0;
}
 

二叉搜索树的数组实现

tree.h:/*** 二叉搜索树模块的接口*/// 树的元素的类型. #define TREE_TYPE  int   // --------------------------外部接口------...
  • dingyuanpu
  • dingyuanpu
  • 2010年08月13日 13:54
  • 2157

二叉搜索树的简单实现(Binary Search Tree)

一、二叉搜索树的概念 二叉搜索树,又称二叉排序树,二叉查找树,他能够高效的完成数据的插入,查询,删除操作,是一种高效的数据结构。 如下图就是一个构建好的二叉搜索树。 特点:    ...
  • chaiwenjun000
  • chaiwenjun000
  • 2015年09月18日 19:49
  • 1020

剑指offer 面试题27—二叉搜索树与双向链表

题目: 输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表,要求不能创建任何新节点,只能调整树中结点指针的指向。最后输出排序后双向链表。 基本思想: 二叉树中每个节点都有两个...
  • wtyvhreal
  • wtyvhreal
  • 2015年05月11日 22:19
  • 872

二叉搜索树BST的C++实现

BST 包含的功能:插入,删除,查找,查找某一结点的后续和前驱,中序遍历和前序遍历 这里,用于实验的二叉树: //二叉搜索树BST #include #include using names...
  • liuchenjane
  • liuchenjane
  • 2016年11月05日 17:58
  • 2216

二叉查找树的C++实现

二叉查找树的插入和删除详解请看:http://blog.csdn.net/sysu_arui/article/details/7865864 前面详细讲解了二叉查找树插入和删除,现在给出完整的C++...
  • sysu_arui
  • sysu_arui
  • 2012年08月21日 18:11
  • 2224

二叉搜索树与双向链表(java版)

题目描述 输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点,只能调整树中结点指针的指向。 分析:      对于二叉搜索树,用中序搜索...
  • hll174
  • hll174
  • 2016年03月27日 22:18
  • 977

二叉搜索树与双向链表Java

题目:输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点,只能调整树中结点指针的方向。 思路:在二叉搜索树中,左子结点的值总是小于父子结点的值,右子结点的值总是大于...
  • u013238950
  • u013238950
  • 2016年03月08日 18:51
  • 852

二叉查找树的简单模板实现

二叉排序树又称二叉查找树,是一种的高效的查找数据结构,查找效率等同二分法。   以下是二叉查找树的一种简单模板实现:   #include using namespace std; t...
  • RO_wsy
  • RO_wsy
  • 2012年06月24日 15:39
  • 998

【剑指Offer】二叉搜索树与双向链表

题目描述输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点,只能调整树中结点指针的指向。算法描述使用递归,分别去将当前节点的左右子树变成双向链表,然后获取左边链表的最...
  • zgljl2012
  • zgljl2012
  • 2015年09月19日 02:11
  • 1850

二叉查找树 C++实现

二叉查找树C++实现
  • mimi9919
  • mimi9919
  • 2016年04月10日 20:27
  • 2231
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:二叉搜索树实现与测试
举报原因:
原因补充:

(最多只允许输入30个字)