设置哨兵的顺序查找,二分查找,二叉平衡树,二叉排序树

本文深入解析查找算法,涵盖顺序查找、折半查找、二叉排序树及平衡二叉树(AVL树)的原理与实现。详细介绍不同查找方法的适用场景、效率分析及代码示例。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

查找的基本概念
列表:由同一类型的数据元素组成的集合。
关键码:数据元素中的某个数据项,可以标识列表中的一个或一组数据元素。
键值:关键码的值。

主关键码:可以唯一地标识一个记录的关键码。

次关键码:不能唯一地标识一个记录的关键码。

静态查找 :不涉及插入和删除操作的查找 。
动态查找 :涉及插入和删除操作的查找

普通的顺序查找基本思想:
从线性表的一端向另一端逐个将关键码与给定值进行比较,
若相等,则查找成功,给出该记录在表中的位置;
若整个表检测完仍未找到与给定值相等的关键码,则查找失败,给出失败信息。
int LineSearch :: SeqSearch(int k)
{
i=n;
while (i>0 && data[i]!=k)
i–;
return i;
}
改进的顺序查找基本思想:设置“哨兵”。哨兵就是待查值,将它放在查找方向的尽头。免去了在查找过程中每一次比较后都要判断查找位置是否越界,从而提高查找速度。

int LineSearch :: SeqSearch(int k)
{ 
    int i = length;        //从数组高端开始比较
    data[0] = k;           //设置哨兵
    while (data[i] != k) //不用判断下标i是否越界
        i--;
    return i; 
}

重点data[0]=k;
单链表的顺序查找

int LinkSearch::SeqSearch2(Node *first, int k){  
    Node *p;
    int count=0;//记录比较的次数
    p=first->next; 
    int j=1;//记录数据在表中的位置
      while (p &&  p->data != k)
    {p=p->next;    j++;    count++;}
    if (!p){
             cout<<“查找失败,比较的次数为:"<<count<<endl;     
             return 0;
     } else{
        cout<<“\n”<<“查找成功,比较的次数为:"<<count<<endl;      
          return j;
    }
}

折半查找
线性表中的记录必须按关键码有序
必须采用顺序存储。
基本思想:
在有序表中(low, high,low<=high),取中间记录作为比较对象,若给定值与中间
记录的关键码相等,则查找成功;若给定值小于中间记录的关键码,则在中间记录的
左半区继续查找;若给定值大于中间记录的关键码,则在中间记录的右半区继续查找。
不断重复上述过程,直到查找成功,或所查找的区域无记录,查找失败。

int LineSearch :: BinSearch1(int k){
     int mid, low = 1, high = length; //初始查找区间是[1, n]
     while (low <= high) {//当区间存在时
          mid = (low + high) / 2; 
          if (k < data[mid]) 
              high = mid - 1;
          else if (k > data[mid]) 
               low = mid + 1; 
          else
               return mid; //查找成功,返回元素序号
      }
      return 0; //查找失败,返回0
}
//递归
int LineSearch :: BinSearch2(int low, int high, int k){
      if (low > high) 
          return 0; //递归的边界条件
      else {
         int mid = (low + high) / 2;
      if (k < data[mid]) 
           return BinSearch2(low, mid-1, k);
      else if (k > data[mid]) 
           return BinSearch2(mid+1, high, k); 
      else 
           return mid; //查找成功,返回序号
     }
}

折半查找判定树
判定树:折半查找的过程可以用二叉树来描述,树中的每个结点对应有序表中的一个记录,结点的值为该记录在表中的位置。通常称这个描述折半查找过程的二叉树为折半查找判定树,简称判定树。
判定树的构造方法
⑴ 当n=0时,折半查找判定树为空;
⑵ 当n>0时,
折半查找判定树的根结点为mid=(n+1)/2
根结点的左子树是与有序表r[1] ~ r[mid-1]相对应的折半查找判定树,
根结点的右子树是与r[mid+1] ~ r[n]相对应的折半查找判定树。
任意两棵折半查找判定树,若它们的结点个数相同,则它们的结构完全相同
具有n个结点的折半查找树的高度为log2n +1
任意结点的左右子树中结点个数最多相差1
任意结点的左右子树的高度最多相差1
任意两个叶子所处的层次最多相差1

查找成功:在表中查找任一记录的过程,即是折半查找判定树中从根结点到该记录结
点的路径,和给定值的比较次数等于该记录结点在树中的层数。
查找成功时的平均查找长度ASL: ASL=(n+1/n)log2(n+1)-1
查找不成功:
查找失败的过程就是走了一条从根结点到外部结点的路径,
和给定值进行的关键码的比较次数等于该路径上内部结点的个数(失败情况下的平均
查找长度等于树的高度)。

二叉排序树

二叉排序树(也称二叉查找树):或者是一棵空的二叉树,或者是具有下列性质的二
叉树:
==⑴若它的左子树不空,则左子树上所有结点的值均小于根结点的值;
⑵若它的右子树不空,则右子树上所有结点的值均大于根结点的值;==
==⑶ 它的左右子树也都是二叉排序树。==
#include <iostream>
using namespace std;
template <class DataType> 
struct BiNode{    DataType data;     BiNode *lchild, *rchild;  };
class BiSortTree {
public:
    BiSortTree(int a[ ], int n); //建立查找集合a[n]的二叉排序树
     ~ BiSortTree( ){ Release(root); } //析构函数,同二叉链表的析构函数
    void InOrder( ){InOrder(root);} //中序遍历二叉树
    BiNode *InsertBST(int x) {return InsertBST(root, x);} //插入记录x
    BiNode *SearchBST(int k) {return SearchBST(root, k);} //查找值为k的结点
    void DeleteBST(BiNode *p, BiNode *f ); //删除f的左孩子p
private:
   void Release(BiNode *bt);
   BiNode *InsertBST(BiNode *bt , int x);  
   BiNode *SearchBST(BiNode *bt, int k); 
   void InOrder(BiNode *bt); //中序遍历函数调用
   BiNode *root; //二叉排序树的根指针
};
void BiSortTree :: InOrder(BiNode *bt) 
{
    if (bt == nullptr) return; //递归调用的结束条件
    else {
    InOrder(bt->lchild); //前序递归遍历bt的左子树
    cout << bt->data << "    "; //访问根结点bt的数据域
    InOrder(bt->rchild); //前序递归遍历bt的右子树 
    }
}

BiNode * BiSortTree :: SearchBST(BiNode *bt, int k)
{
    if (bt == nullptr) return nullptr;
    if (bt->data == k) return bt;
    else if (bt->data > k) return SearchBST(bt->lchild, k);
    else return SearchBST(bt->rchild, k);
}
BiNode *BiSortTree::InsertBST(BiNode *bt, int x)
{
    if (bt == nullptr)
    { //找到插入位置
        BiNode *s = new BiNode; 
        s->data = x;
        s->lchild = nullptr; s->rchild = nullptr;
        bt = s;
        return bt;
    }
    else if (bt->data > x) bt->lchild = InsertBST(bt->lchild, x);
    else bt->rchild = InsertBST(bt->rchild, x);
}
/*void InsertBST(BiNode<int> * & root , BiNode<int> *s);
分析:若二叉排序树为空树,则新插入的结点为新的根结点;否则,新插入的结点必
为一个新的叶子结点,其插入位置由查找过程得到。
若二叉排序树为空树,则新插入的结点为新的根结点;否则,如果插入的值比根节点
值大,则在右子树中进行插入;否则,在左子树中进行插入。
递归。*/
BiSortTree::BiSortTree(int a[ ], int n)
{
    root = nullptr;
    for (int i = 0; i < n; i++)
    root = InsertBST(root, a[i]);
}

void BiSortTree::DeleteBST(BiNode *p, BiNode *f ) 
{
    if ((p->lchild == nullptr) && (p->rchild == nullptr))
    { //p为叶子
        f->lchild = nullptr; 
        delete p; 
        return;
    }
    if (p->rchild == nullptr) 
    { //p只有左子树
        f->lchild = p->lchild; 
        delete p; 
        return;
    }
    if (p->lchild == nullptr) 
    { //p只有右子树
        f->lchild = p->rchild; 
        delete p; 
        return;
    }
    BiNode *par = p, *s = p->rchild; //p的左右子树均不空
    while (s->lchild != nullptr) //查找最左下结点
    {
        par = s;
        s = s->lchild;
    }
    p->data = s->data;
    if (par == p)  par->rchild = s->rchild; //特殊情况,p的右孩子无左子树
    else par->lchild = s->rchild; 
    delete s;
} 

void BiSortTree :: Release(BiNode *bt)
{
    if (bt == nullptr) return;
    else{
        Release(bt->lchild); //释放左子树
        Release(bt->rchild); //释放右子树
        delete bt; //释放根结点
    }
}

int main( )
{
    BiNode *p = nullptr;
    int arr[10] = {7 ,2, 3, 10, 5, 6, 1, 8, 9, 4};
    BiSortTree B{arr,10}; 
    B.InOrder();
    int key;
    cout << "请输入查找的元素值";
    cin >> key; 
    p = B.SearchBST(key);
    if (p != nullptr) cout << p->data << endl;
    else  cout << "查找失败" << endl;
    system("pause");
    return 0;
}

BiNode *BiSortTree::InsertBST(BiNode *bt, int x)
{
    if (bt == NULL) { //找到插入位置
        BiNode *s = new BiNode; 
        s->data = x;
        s->lchild = NULL;
        s->rchild = NULL;
        bt = s;
        return bt;
    }
    else if (bt->data > x) 
        bt->lchild = InsertBST(bt->lchild, x);
    else
        bt->rchild = InsertBST(bt->rchild, x);
}
BiSortTree::BiSortTree(int a[ ], int n)
{
    root = NULL;
    for (int i = 0; i < n; i++)
        root = InsertBST(root, a[i]);
}

在二叉排序树上删除某个结点之后,仍然保持二叉排序树的特性。
分三种情况讨论:
1、被删除的结点是叶子;
操作:将双亲结点中相应指针域的值改为空。
2、被删除的结点只有左子树或者只有右子树;
操作:将双亲结点的相应指针域的值指向被删除结点的左子树(或右子树)。
3、被删除的结点既有左子树,也有右子树。
操作:以其前驱(左子树中的最大值)替代之,然后再删除该前驱结点。

二叉排序树的删除算法——伪代码
1.若结点p是叶子,则直接删除结点p;
2. 若结点p只有左子树,则只需重接p的左子树;
若结点p只有右子树,则只需重接p的右子树;
3. 若结点p的左右子树均不空,则
3.1 查找结点p的右子树上的最左下结点s及s双亲结点par;
3.2 将结点s数据域替换到被删结点p的数据域;
3.3 若结点p的右孩子无左子树,
则将s的右子树接到par的右子树上;
否则,将s的右子树接到结点par的左子树上;
3.4 删除结点s;

在二叉排序树中查找给定值k的过程是:
⑴ 若root是空树,则查找失败;
⑵ 若k=root->data,则查找成功;否则
⑶ 若k<root->data,则在root的左子树上查找;否则
⑷ 在root的右子树上查找。
上述过程一直持续到k被找到或者待查找的子树为空,如果待查找的子树为空,则查找失败。
二叉排序树的查找效率在于只需查找二个子树之一。

删除的两种方法
s->rchild = p->rchild;
p = p->lchild;

void delete_Node1(BSTree &p)	
{ 
	BSTree q,s;
	if(!p->lchild)	//由于这个if在前面,所以左右子树均为空的情况会在这里处理 
	{	//如果左子树为空,则只需重接其右子树
		q = p;
		p = p->rchild ;
		free(q);
	}
	else if(!p->rchild)
	{	//如果右子树为空,则只需重接其左子树
		q = p;
		p = p->lchild;
		free(q);
	}
	else
	{	//如果左右子树都不为空,这里采取修改左子树的方法,也可以修改右子树,方法类似
		s = p->lchild;		//取待删节点的左孩子结点
 
		while(s->rchild)	//找到中序遍历时会得到的直接前驱 
			s = s->rchild;
		s->rchild = p->rchild;	//将p的右子树接为s的右子树
		q = p;
		p = p->lchild;		//将p的左子树直接接到其父节点的左子树上
		free(q);
	}
}

用s代替被删除的节点
p->data = s->data;

void delete_Node2(BSTree &p)
{
	BSTree q,s;		
	if(!p->lchild)		//由于这个if在前面,所以左右子树均为空的情况会在这里处理 
	{	//如果左子树为空,则只需重接其右子树
		q = p;
		p = p->rchild ;
		free(q);
	}
	else if(!p->rchild)
	{	//如果右子树为空,则只需重接其左子树
		q = p;
		p = p->lchild;
		free(q);
	}
	else
	{	//如果左右子树都不为空,采取修改左子树的方法,也可以修改右子树,方法类似
		q = p;
		s = p->lchild;		//取待删节点的左节点
		while(s->rchild)		
		{		//找到中序遍历时会得到的直接前驱 
			q = s;
			s = s->rchild;
		}
		//用s来替换待删节点p
		p->data = s->data;  
		//根据情况,将s的左子树重接到q上
		if(p != q) q->rchild = s->lchild;
		else q->lchild =s->lchild;
		free(s);
	}
}
BiNode *BiSortTree::SearchBST(BiNode<int> *root, int k)
{
    if (root == NULL)
        return NULL;
    else if (root->data==k) 
        return root;
    else if (k<root->data) 
        return SearchBST(root->lchild, k);
    else 
        return SearchBST(root->rchild, k);
}

平衡二叉树(AVL树)
平衡二叉树:或者是一棵空的二叉排序树,或者是具有下列性质的二叉排序树:
⑴ 根结点的左子树和右子树的深度最多相差1;
⑵ 根结点的左子树和右子树也都是平衡二叉树。
平衡因子:结点的平衡因子是该结点的左子树的深度与右子树的深度之差。
最小不平衡子树:在平衡二叉树的构造过程中,以距离插入结点最近的、且平衡因子
的绝对值大于1的结点为根的子树。
基本思想:
在构造二叉排序树的过程中,每插入一个结点时,首先检查是否因插入而破坏了树的
平衡性,若是,则找出最小不平衡子树,在保持二叉排序树特性的前提下,调整最小
不平衡子树中各结点之间的链接关系,进行相应的旋转,使之成为新的平衡子树。

在平衡树中,结点的平衡因子可以是1,0,-1。
最小不平衡子树:在平衡二叉树的构造过程中,以距离插入结点最近的、且平衡因子的绝对值大于1的结点为根的子树
在一个平衡二叉排序树上插入一个新结点S时,主要包括以下三步:
(1)查找应插位置, 同时记录离插入位置最近的可能失衡结点A(A的平衡因子不等
于0)。
(2)插入新结点S, 并修改从A到S路径上各结点的平衡因子。
(3)根据A、 B的平衡因子, 判断是否失衡以及失衡类型, 并做相应处理。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值