查找——二叉排序树

查找

列表:由同一类型的数据元素组成的集合。
关键码:数据元素中的某个数据项,可以标识列表中的一个或一组数据元素。
键值:关键码的值。
主关键码:可以唯一地标识一个记录的关键码。
次关键码:不能唯一地标识一个记录的关键码。
查找 :在具有相同类型的记录构成的集合中找出满足给定条件的记录。
查找的结果 :若在查找集合中找到了与给定值相匹配的记录,则称查找成功;否则,称查找失败。
静态查找 :不涉及插入和删除操作的查找 。
动态查找 :涉及插入和删除操作的查找。
查找结构 :面向查找操作的数据结构 ,即查找基于的数据结构。
平均查找长度:将查找算法进行的关键码的比较次数的数学期望值定义为平均查找长度。

查找方式

1、顺序查找:

int SeqSearch1(int r[ ], int n, int k)//数组r[1] ~ r[n]存放查找集合
{   
     i=n;
     while (i>0 && r[i]!=k)
         i--;
     return i;
}

改进的顺序查找
基本思想:设置“哨兵”。
哨兵就是待查值,将哨兵放在查找方向的尽头处,免去了在查找过程中每一次比较后都要判断查找位置是否越界,从而提高查找速度。

int SeqSearch2(int r[ ], int n, int k) //数组r[1] ~ r[n]存放查找集合
{   
     r[0]=k; i=n;
     while (r[i]!=k)
        i --;
     return i;
}

单链表的顺序查找

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 BinSearch2(int r[ ], int low, int high, int k)
{
    if (low>high)
        return 0;
    else
    {
        mid=(low+high)/2;
        if (k<r[mid])
            return BinSearch2(r, low, mid-1, k);
        else  if (k>r[mid])
            return BinSearch2(r, 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]相对应的折半查找判定树。
判定树的特点
任意两棵折半查找判定树,若它们的结点个数相同,则它们的结构完全相同。
判定树的性质
任意结点的左右子树中结点个数最多相差1。
任意结点的左右子树的高度最多相差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; //二叉排序树的根指针
};

构造

BiSortTree::BiSortTree(int a[ ], int n)
{
	root = NULL;
	for (int i = 0; i < n; i++)
		root = InsertBST(root, a[i]);
}

插入

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);
}

删除

void BiSortTree::DeleteBST(BiNode<int> *p, BiNode<int> *f ) {
  if (!p->lchild && !p->rchild)  {   
              if(f->child==p)        f->lchild= NULL;  
              else  f->lchild= NULL; 
              delete p;
   }
  else if (!p->rchild) {     //p只有左子树
             if(f->child==p)   f->lchild=p->lchild;
             else f->rchild=p->lchild;
                delete p;
  }
  else if (!p->lchild) {   //p只有右子树
   if(f->child==p)  f->lchild=p->rchild;
   else f->rchild=p->rchild;
            delete p;
         }
        else {   //左右子树均不空
             par=p;  s=p->rchild;  
             while (s->lchild!=NULL)   //查找最左下结点
             {
               par=s;
               s=s->lchild;
             }
             p->data=s->data;
             if (par==p) p->rchild=s->rchild;  //处理特殊情况
                 else par->lchild=s->rchild;    //一般情况
             delete s;
           } //左右子树均不空的情况处理完毕
 }

二叉排序树的查找

BiNode *BiSortTree::SearchBST(BiNode<int> *root, int k)
{
    if (root==NULL)
    return NULLelse if (root->data==k) 
              return root;
    else if (k<root->data) 
              return SearchBST(root->lchild, k);
    else 
          return SearchBST(root->rchild, k);
}

二叉排序树的查找性能取决于二叉排序树的形状,在O(log2n)和O(n)之间。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉搜索树,也叫二叉查找树(BST,Binary Search Tree),是一种特殊的二叉树。相对于普通的二叉树,它有一个特点:所有左子树的节点都比根节点小,所有右子树的节点都比根节点大。因此,它可以快速地进行查找、插入、删除等操作。 具体来说,二叉搜索树的定义如下: - 节点的左子树中所有节点的值都小于该节点的值。 - 节点的右子树中所有节点的值都大于该节点的值。 - 左右子树也都是二叉搜索树。 如下图所示,就是一个二叉搜索树的例子: ``` 8 / \ 3 10 / \ \ 1 6 14 / \ / 4 7 13 ``` 在这个树中,每个节点都满足左子树的节点值小于该节点的值,右子树的节点值大于该节点的值。比如,节点 3 的左子树是 1 和 6,右子树是 4 和 7,都满足要求。 二叉搜索树的主要操作包括查找、插入和删除。 查找操作可以通过递归或者循环实现。递归实现如下: ``` def search(root, val): if not root or root.val == val: return root if root.val > val: return search(root.left, val) else: return search(root.right, val) ``` 插入操作需要先查找到插入的位置,然后创建一个新节点插入到该位置: ``` def insert(root, val): if not root: return TreeNode(val) if root.val > val: root.left = insert(root.left, val) else: root.right = insert(root.right, val) return root ``` 删除操作比较复杂,需要考虑多种情况。如果要删除的节点只有一个子节点,直接将其子节点替换上来即可。如果要删除的节点有两个子节点,可以找到其右子树中的最小节点(或者左子树中的最大节点)来替换该节点,然后再删除该最小节点(或者最大节点)。 ``` def delete(root, val): if not root: return None if root.val == val: if not root.left: return root.right elif not root.right: return root.left else: # 找到右子树中的最小节点 p = root.right while p.left: p = p.left root.val = p.val root.right = delete(root.right, p.val) elif root.val > val: root.left = delete(root.left, val) else: root.right = delete(root.right, val) return root ``` 需要注意的是,在删除节点时,要保证删除后的树仍然是二叉搜索树。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值