二叉搜索树实现与测试

原创 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;
}
 

常见的二叉搜索树的实现代码

  • 2009年08月14日 11:12
  • 1.84MB
  • 下载

c语言实现二叉搜索树

  • 2014年03月23日 21:06
  • 6KB
  • 下载

数据结构——平衡二叉搜索树(AvlTree)的实现

平衡二叉搜索树是二叉搜索树的升级版本。它拥有二叉搜索树的所有特性,同时它对子树的高度也进行了一定的限制。所以平衡二叉搜索树不会退化成链表的形式,而是维持了一个比较平衡的二叉树状态。...

VC/C++实现二叉搜索树查找算法

  • 2010年12月21日 16:33
  • 468KB
  • 下载

二叉搜索树 -【动态规划】最优C++实现

程序在VC++6.0下编译通过 1 #include iostream> 2 #include fstream> 3 #include string> 4 #include li...

霍夫曼树和二叉搜索树代码实现

  • 2012年03月01日 17:01
  • 13KB
  • 下载

二叉搜索树的基本java实现

package zcj; /** * Created by admin on 2016/4/15. */ public class BinarySearchTree { //定义一个二叉...
  • whu_zcj
  • whu_zcj
  • 2016年04月15日 15:59
  • 159

二叉搜索树的c++实现

  • 2014年07月05日 16:38
  • 9KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:二叉搜索树实现与测试
举报原因:
原因补充:

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