算法导论学习笔记(八):二叉查找树

前言

昨天复习完了二叉树,今天终于可以很好的展开对二叉查找树的学习了。言归正传,查找树是一种数据结构,支持多

动态集合操作,包括SEARCH、MINIMUM、MAXIMUM、PREDECESSOR、SUCCESSOR、INSERT以及

DELETE。


定义

一颗二叉查找树是按二叉树结构来组织的。这样的树可以用链表结构来表示,其中每一个结点都是一个对象。结点中

了key域和卫星数据外,还包括域lchild、rchild和p,它们分别指向结点的做子树和右子树和父节点。如果某个子树

不存在,则相应的指针域中的值为NULL。


特性

为了方便起见,下面参照书上的写好,key[x]表示结点x的关键字。对于二叉查找树,任何结点x,其左子树的关键字

大不超过key[x],其右子树中的关键字最小不小于key[x]。不同的二叉查找树可以表示同一组值,这和建立二叉查找

树时插入结点的次序有关。后面的练习题12.2-1可以帮组理解,答案是C。下图便是一颗二叉查找树:



几种常见的操作的实现

在前言里提到的这些操作里,用到的最频繁的应该是查找、插入和删除操作了。其它几个操作比较简单,这里就没提

及。在这三个操作中,最复杂的应该就算是删除操作了。下面一个个来讲:

1、查找操作

对于二叉查找树来说,这应该是最常见的操作。该操作是查找树中的某个关键字。

/*************************************************
** 查找关键字key是否在二叉查找树中
** 若存在则返回TRUE,且p存储二叉树中关键字所在地址
** 若不存在则返回FALSE,且p为NULL
**************************************************/
BiTree SearchTree (BiTree T, int key)
{
	if ((T == NULL) || (key == T->data))
		return T;
	else if (key < T->data)
	{
		return SearchTree (T->lchild, key);
	}
	else
	{
		return SearchTree (T->rchild, key);
	}
}
不难看出,该过程是沿着树的根结点开始进行查找的,并沿着树下降。在递归查找过程中遇到的结点构成了一条由根

结点到所要查找的结点的路径。其时间复杂度为O(h),h为树的高度。

2、插入操作

因为我这里直接没有设卫星数据,所以只要给出要插入结点的关键字即可完成插入操作,后面的删除操作也是这样

的。当然,如果你自己添加了卫星数据,只要传递一个结点的数据类型的变量即可。

我们应该注意,在插入结点后应该保证此时的树仍然是一颗二叉查找树,代码如下:

/********************************************** 
** 向二叉查找树插入一个元素 
** 若元素已经存在,则不作任何操作 
** 若元素还没有,则插入,并保持二叉查找树的性质 
***********************************************/  
void TreeInsert (BiTree* T, int key)  
{  
    if (!SearchTree (*T, key))  
    {  
        BiTree y = NULL;  
        BiTree x = *T;  
        while (x)  //找出结点y,将新结点作为y的子结点插入  
        {  
            y = x;  
            if (key < x->data)  
                x = x->lchild;  
            else  
                x = x->rchild;  
        }  
  
        BiTree s = new BitNode;   //根据给出关键字建立新结点  
        s->data = key;  
        s->rchild = s->lchild = NULL;
        s->p = y;
  
        if (NULL == y)  //表示树为空,则插入的结点作为根结点  
            *T = s;  
        else if (key < y->data)  //新结点作为y的左子结点  
            y->lchild = s;  
        else                     //新结点作为y的右子结点  
            y->rchild = s;  
    }  
}


3、删除操作

最后一个常用操作,也是最复杂的一个了。删除一个结点后,就要把断开处链接起来。总的来说,有三种情况:

a、删除的结点没有子结点。这是最理想的一种情况了,这种情况下我们只要把这个结点的内存释放就可以了;

b、删除的结点只有一个子结点。这种情况相对来说也很好处理,只要将指向其自身的指针指向子结点,然后释放自 

     己所占内存即可;

c、删除的结点有两个子结点。这是最让人头疼的了,处理方式是先找出其直接先驱结点(直接后驱结点),然后用前驱

     结点(后驱结点)的关键字代替该结点。再将前驱结点(后驱结点)的父结点和子结点线连接。

实现代码如下(我的代码里是采用后驱结点的):

/********************************** 
** 删除给定结点 
** 以删除结点直接后驱来替代删除结点 
** 也可以用直接前驱结点来替代 
***********************************/  
bool Delete (BiTree* T)  
{  
    BiTree q, s;  
	if (((*T)->lchild == NULL) && ((*T)->rchild == NULL)) //左右子树都为空
	{
		if (*T == (*T)->p->lchild)
			(*T)->p->lchild = NULL;
		else
			(*T)->p->rchild = NULL;
		delete *T;
	}
	else if ((*T)->lchild == NULL) //左子树为空,直接连接右子树。这里还包括没有子树的情况  
    {  
        q = *T;  
        *T = (*T)->rchild;
		(*T)->p = q->p;
		if (q == q->p->lchild)
			q->p->lchild = *T;
		else
			q->p->rchild = *T;
        delete q;  
    }  
    else if ((*T)->rchild == NULL) //右子树为空,直接连接左子树  
    {  
        q = *T;  
        *T = (*T)->lchild;
		(*T)->p = q->p;
		if (q == q->p->lchild)
			q->p->lchild = *T;
		else
			q->p->rchild = *T;
        delete q;  
    }  
    else //左子树和右子树都有  
    {  
        q = *T;  
        s = (*T)->rchild;  
        while (s->lchild)  
        {  
            q = s;  
            s = s->lchild;  
        }  
        (*T)->data = s->data;  //s为删除结点的直接后驱结点  
        if (q == *T)           //q为s的父节点  
            q->rchild = s->rchild;  
        else  
            q->lchild = s->rchild;  
        delete s;  
    }  
    return true;  
}  

/********************* 
** 根据关键字删除结点 
** 删除成功则返回TRUE 
** 删除失败返回FALSE 
**********************/  
bool TreeDelete (BiTree* T, int key)  
{  
    if (!*T)  
        return false;  
    else  
    {  
        if (key == (*T)->data)  
            return Delete (T);  
        else if (key < (*T)->data)  
            return TreeDelete (&(*T)->lchild, key);  
        else  
            return TreeDelete (&(*T)->rchild, key);  
    }  
}

上面我自己的实现还是比较复杂的,下面贴出的是直接根据《算法导论》上给的伪代码实现的代码:

void TreeDelete (BiTree* T, int key)  
{  
	BiTree z = SearchTree (*T, key);
	
	BiTree x, y;
	if ((z->lchild == NULL) || (z->rchild == NULL))
		y = z;
	else
		y = Tree_Successor (z);

	if (y->lchild != NULL)
		x = y->lchild;
	else
		x = y->rchild;

	if (x != NULL)
		x->p = y->p;

	if (y->p == NULL)
		*T = x;
	else if (y == y->p->lchild)
		y->p->lchild = x;
	else
		y->p->rchild = x;

	if (y != z)
		z->data = y->data;
	delete y;
}



扩展:基数树

给定两个串a = a0a1……ap和b = b0b1……b1,其中每一个ai和每一个bj都属于某个有序字符集,如果下面两条规则

之一成立,则说串a按字典序小于串b:

1)存在一个整数j,0<=j<=min(p,q),使得ai=bi,i=0,1,……,j-1,且aj<bj;

2)p<q,且ai=bi,对所有的i=0,1,……,p成立

例如,如果a和b是位串,则根据规则1)(设j=3),有10100 < 10110;根据规则2),有10100 < 101000。这与英语字典中的排序很相似。

图12-5中示出的是基数树(radix tree)数据结构,其中存储了位串1011、10、011、100和0。当查找某个关键字a = a0a1……ap时,在深度为i的一个结点处,若ai = 0则向左转;若ai = 1则向右转。设S为一组不同的二进制串构成的集合,各串的长度之和为n。说明如何利用基数树,在O(n)时间内对S按字典序排序。例如,对图12-5中每个结点的关键字,排序的输出应该是序列0、011、10、100、1011

实现代码:

#include<iostream>
#include<string>
using namespace std;

typedef struct BitNode
{
	string str;
	struct BitNode *lchild, *rchild;
	BitNode():str(""),lchild(NULL),rchild(NULL){}
}BiTNode, *BiTree;

void TreeInsert (BiTree* T, string s)
{
	BiTree p, q;
	q = *T;

	for (int i = 0; i < s.length(); i++)
	{
		if (s[i] == '0')
		{
			if (NULL == q->lchild)
			{
				p = new BiTNode;
				q->lchild = p;
			}
			else
			{
				p = q->lchild;
			}
		}
		else
		{
			if (NULL == q->rchild)
			{
				p = new BiTNode;
				q->rchild = p;
			}
			else
			{
				p = q->rchild;
			}
		}
		if (i == (s.length() - 1))
		{
			p->str = s;
		}
		else
		{
			q = p;
		}
	}
}

void Print (BiTree T)
{
	if (!T)
		return ;
	if (T->str != "")
		cout << T->str << endl;
	Print (T->lchild);
	Print (T->rchild);
}

int main()  
{  
    string str, x;  
    BiTree T = new BiTNode;

    while(1)  
    {  
        cin>>str;  
        if(str == "I")  
        {  
            cin>>x;  
            TreeInsert(&T, x);  
        }  
        else if(str == "P")  
        {  
            Print(T);  
            cout<<endl;  
        }  
    }  
    return 0;  
}  



参考文献

算法导论-12-2-基数树




  • 16
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值