次优查找树的实现【严蔚敏】

最新推荐文章于 2023-06-30 19:55:54 发布
最新推荐文章于 2023-06-30 19:55:54 发布
阅读量6k 收藏 24
点赞数 7
分类专栏： 数据结构与算法 文章标签： 数据结构与算法 查找算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MooMLu/article/details/70833481
版权

考虑查找成功时的情况：查找性能最佳的判别树是带权路径之和PH的值。

最优查找树：
用数学公式来表示就是：使得 PH = \sum_{i=1}^{n}{\omega_{i}h_{i}} 的PH值最小的树为该数组的静态最优查找树。其中i为节点标号， \omega _{i}为节点i的带权路径长度， \omega _{i} = c _{i} * p _{i}，它等于结点i的查找路径长度c，乘以该结点被查找的概率p；h表示节点i在搜索树中的高度。通俗点来说，就是权值越大的结点，越放到靠近根结点的位置。可能查找概率大，需要的比较次数（折半查找中的次数）多，或者两者皆有。
次优二叉树：
选出一个结点，使得它左右两侧的子数组的 权值累加和之差 的绝对值最小。把这个结点当做根节点，递归地用刚才的左右字数组构造它的左右子树。
数学表达式： \Delta P_{i} = |\sum_{j=i+1}^{h}{\omega _{j}} - \sum_{j=l}^{i-1}{\omega _{j}}| 。 
Status SecondOptimal(BiTree &T, ElemType R[],int sw[],int low,int high)
 { // 由有序表R[low..high]及其累计权值表sw(其中sw[0]==0)递归构造
   // 次优查找树T。算法9.3
   int i,j;
   double min,dw;
   i=low;
   min=fabs(sw[high]-sw[low]);
   dw=sw[high]+sw[low-1];
   for(j=low+1;j<=high;++j) // 选择最小的△Pi值
      if(fabs(dw-sw[j]-sw[j-1])<min)
      {
       i=j;
       min=fabs(dw-sw[j]-sw[j-1]);
     }
   if(!(T=(BiTree)malloc(sizeof(BiTNode))))
     return ERROR;
     
        T->data=R[i]; // 生成结点
   if(i==low)
        T->lchild=NULL; // 左子树空
   else
        SecondOptimal(T->lchild,R,sw,low,i-1); // 构造左子树
   if(i==high)
        T->rchild=NULL; // 右子树空
   else
        SecondOptimal(T->rchild,R,sw,i+1,high); // 构造右子树
   return OK;
 }



 
void FindSW(int sw[],SSTable ST)
 { // 按照有序表ST中各数据元素的Weight域求累计权值表sw
   int i;
   sw[0]=0;
   for(i=1;i<=ST.length;i++)
     sw[i]=sw[i-1]+ST.elem[i].weight;
 }


Status CreateSOSTree(SOSTree &T,SSTable ST)
 { // 由有序表ST构造一棵次优查找树T。ST的数据元素含有权域weight。算法9.4
   if(ST.length==0)
     T=NULL;
   else
   {
     FindSW(sw,ST); // 按照有序表ST中各数据元素的Weight域求累计权值表sw
     SecondOptimal(T,ST.elem,sw,1,ST.length);
   }
   return OK;
 }
代码完整实现： 


 // algo9-3.cpp 静态查找表(静态树表)的操作
 #include <stdio.h>
 #include <malloc.h>
 #include <math.h>
 #include<iostream>             //cout,cin
using namespace std; 
 // 函数结果状态代码
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 // #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
 typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
 typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE
 #define N 9 // 数据元素个数
 #define EQ(a,b) ((a)==(b))
 #define LT(a,b) ((a)<(b))
 #define LQ(a,b) ((a)<=(b))
 typedef char KeyType; // 设关键字域为字符型
 struct ElemType // 数据元素类型(以教科书例9-1为例)
 {
   KeyType key;
   int weight;
 }r[N]={{'A',1},{'B',1},{'C',2},{'D',5},{'E',3},
       {'F',4},{'G',4},{'H',3},{'I',5}}; // 全局变量
 int sw[N+1]; // 累计权值，全局变量
 typedef ElemType TElemType;
  typedef struct
 {
   ElemType *elem; // 数据元素存储空间基址，建表时按实际长度分配，0号单元留空
   int length; // 表长度
 }SSTable;
  //  静态查找表(顺序表和有序表)的基本操作(7个)
 Status Creat_Seq(SSTable &ST,int n)
 { // 操作结果: 构造一个含n个数据元素的静态顺序查找表ST(数据来自全局数组r)
   int i;
   ST.elem=(ElemType*)calloc(n+1,sizeof(ElemType)); // 动态生成n个数据元素空间(0号单元不用)
   if(!ST.elem)
     return ERROR;
   for(i=1;i<=n;i++)
     *(ST.elem+i)=r[i-1]; // 将全局数组r的值依次赋给ST
   ST.length=n;
   return OK;
 }
 void Ascend(SSTable &ST)
 { // 重建静态查找表为按关键字非降序排序
   int i,j,k;
   for(i=1;i<ST.length;i++)
   {
     k=i;
     ST.elem[0]=ST.elem[i]; // 待比较值存[0]单元
     for(j=i+1;j<=ST.length;j++)
       if LT(ST.elem[j].key,ST.elem[0].key)
       {
         k=j;
         ST.elem[0]=ST.elem[j];
       }
     if(k!=i) // 有更小的值则交换
     {
       ST.elem[k]=ST.elem[i];
       ST.elem[i]=ST.elem[0];
     }
   }
 }
 Status Creat_Ord(SSTable &ST,int n)
 { // 操作结果: 构造一个含n个数据元素的静态按关键字非降序查找表ST
   // 数据来自全局数组r
   Status f;
   f=Creat_Seq(ST,n);
   if(f)
     Ascend(ST);
   return f;
 }

  Status Destroy(SSTable &ST)
 { // 初始条件: 静态查找表ST存在。操作结果: 销毁表ST
   free(ST.elem);
   ST.elem=NULL;
   ST.length=0;
   return OK;
 }

 int Search_Seq(SSTable ST,KeyType key)
 { // 在顺序表ST中顺序查找其关键字等于key的数据元素。若找到，则函数值为
   // 该元素在表中的位置，否则为0。算法9.1
   int i;
   ST.elem[0].key=key; // 哨兵
   for(i=ST.length;!EQ(ST.elem[i].key,key);--i); // 从后往前找
   return i; // 找不到时，i为0
 }

 int Search_Bin(SSTable ST,KeyType key)
 { // 在有序表ST中折半查找其关键字等于key的数据元素。若找到，则函数值为
   // 该元素在表中的位置，否则为0。算法9.2
   int low,high,mid;
   low=1; // 置区间初值
   high=ST.length;
   while(low<=high)
   {
     mid=(low+high)/2;
     if EQ(key,ST.elem[mid].key)  // 找到待查元素
       return mid;
     else if LT(key,ST.elem[mid].key)
       high=mid-1; // 继续在前半区间进行查找
     else
       low=mid+1; // 继续在后半区间进行查找
   }
   return 0; // 顺序表中不存在待查元素
 }

 Status Traverse(SSTable ST,void(*Visit)(ElemType))
 {      // 初始条件: 静态查找表ST存在，Visit()是对元素操作的应用函数
        // 操作结果: 按顺序对ST的每个元素调用函数Visit()一次且仅一次。
       // 一旦Visit()失败，则操作失败
   ElemType *p;
   int i;
   p=++ST.elem; // p指向第一个元素
   for(i=1;i<=ST.length;i++)
     Visit(*p++);
   return OK;
 }
  typedef struct BiTNode
 {
   TElemType data;
   BiTNode *lchild,*rchild; // 左右孩子指针
 }BiTNode,*BiTree;
 Status SecondOptimal(BiTree &T, ElemType R[],int sw[],int low,int high)
 { // 由有序表R[low..high]及其累计权值表sw(其中sw[0]==0)递归构造
   // 次优查找树T。算法9.3
   int i,j;
   double min,dw;
   i=low;
   min=fabs(sw[high]-sw[low]);
   dw=sw[high]+sw[low-1];
   for(j=low+1;j<=high;++j) // 选择最小的△Pi值
      if(fabs(dw-sw[j]-sw[j-1])<min)
      {
       i=j;
       min=fabs(dw-sw[j]-sw[j-1]);
     }
   if(!(T=(BiTree)malloc(sizeof(BiTNode))))
     return ERROR;
     
        T->data=R[i]; // 生成结点
   if(i==low)
        T->lchild=NULL; // 左子树空
   else
        SecondOptimal(T->lchild,R,sw,low,i-1); // 构造左子树
   if(i==high)
        T->rchild=NULL; // 右子树空
   else
        SecondOptimal(T->rchild,R,sw,i+1,high); // 构造右子树
   return OK;
 }
 void FindSW(int sw[],SSTable ST)
 { // 按照有序表ST中各数据元素的Weight域求累计权值表sw
   int i;
   sw[0]=0;
   for(i=1;i<=ST.length;i++)
     sw[i]=sw[i-1]+ST.elem[i].weight;
 }

 typedef BiTree SOSTree; // 次优查找树采用二叉链表的存储结构
 Status CreateSOSTree(SOSTree &T,SSTable ST)
 { // 由有序表ST构造一棵次优查找树T。ST的数据元素含有权域weight。算法9.4
   if(ST.length==0)
     T=NULL;
   else
   {
     FindSW(sw,ST); // 按照有序表ST中各数据元素的Weight域求累计权值表sw
     SecondOptimal(T,ST.elem,sw,1,ST.length);
   }
   return OK;
 }

 Status Search_SOSTree(SOSTree &T,KeyType key)
 { // 在次优查找树T中查找关键字等于key的元素。找到则返回OK，否则返回FALSE
   while(T) // T非空
     if(T->data.key==key)
       return OK;
     else if(T->data.key>key)
       T=T->lchild;
     else
       T=T->rchild;
   return FALSE; // 顺序表中不存在待查元素
 }

 void print(ElemType c) // Traverse()调用的函数
 {
   printf("(%c %d) ",c.key,c.weight);
 }

 int main()
 {
   SSTable st;
   SOSTree t;
   Status i;
   KeyType s;
   Creat_Ord(st,N); // 由全局数组产生非降序静态查找表st
   Traverse(st,print);
   CreateSOSTree(t,st); // 由有序表构造一棵次优查找树
   printf("\n请输入待查找的字符: ");
   scanf("%c",&s);
   i=Search_SOSTree(t,s);
   if(i)
     printf("%c的权值是%d\n",s,t->data.weight);
   else
     printf("表中不存在此字符\n");
 }


MooMLu
关注
  • 7
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构c语言实现严蔚敏版
03-31
单链表、双链表和循环链表是链表的不同变体，它们各有优缺点，适用于不同的场景。 2. 栈：栈是一种后进先出（LIFO）的数据结构，常用于函数调用、表达式求值等。在C语言中，我们可以通过数组或动态分配内存来实现栈...
静态树表的查找（最优查找树和次优查找树）
Keep_Trying_Go的博客
10-24 2784
静态树表的查找（最优查找树和次优查找树）
查找算法 | 静态树表（次优查找树）详细分析
挖坑埋你
11-04 9422
前面章节所介绍的有关在静态查找表中对特定关键字进行顺序查找、折半查找或者分块查找，都是在查找表中各关键字被查找概率相同的前提下进行的。 例如查找表中有 n 个关键字，表中每个关键字被查找的概率都是 1/n。在等概率的情况，使用折半查找算法的性能最优。 而在某些情况下，查找表中各关键字被查找的概率是不同的。例如水果商店中有很多种水果，对于不同的顾客来说，由于口味不同，各种水果可能被选择的概率是不...
次优二叉查找树（次优查找树)_递归和非递归实现_20230414
Jasonchen1224的博客
04-15 1681
数据结构 次优二叉查找树 递归 非递归 C语言
次优二叉树 --- 折半查找在元素不等概情况下的改进
青春不谢的专栏
02-05 3250
1、次优查找树是折半查找的一种一般形式，其理论基础是“被查找的各元素是不等概的”，而折半查找就是等概的，我们在使用中默认了这一性质。 比如，对于有序数组 int a = {1,2,3,4,5}; 用折半查找时，应该现比较最中间的3，如果如果待查整数等于3，查找结束。如果小于3，就继续在左边的部分数组里查找；反之，在右边的数组里查找。 问题在于，我们为什么不从4开始找呢？为什么不从1开始呢？
查找数据结构严蔚敏PPT学习教案.pptx
10-08
例如，这些查找技术可以进一步扩展到二叉搜索树、哈希表等高级数据结构中。同时，通过分析和优化查找算法，我们可以提高程序的运行效率，这对于开发高效软件系统具有重要意义。因此，深入理解和掌握这些基本查找方法...
数据结构与算法c语言 严蔚敏 代码实现
06-04
3. **树形结构**：二叉树是最简单也是最常用的树结构，包括二叉搜索树（BST）、平衡树（AVL、红黑树等），它们支持高效的查找、插入和删除操作。此外，堆（最大堆和最小堆）在优先队列中广泛应用。 4. **图**：图是...
严蔚敏全部代码实现！！！
01-15
二叉查找树的插入和查找操作，展示了二分查找的思想；而平衡树的插入和删除则涉及到复杂的自平衡策略，如旋转操作，以保持树的高度平衡。 此外，搜索算法如二分查找、广度优先搜索（BFS）和深度优先搜索（DFS），在...
严蔚敏数据结构PPT_严蔚敏_algorithm_
10-01
二叉树是最简单的树结构，分为二叉查找树（BST）、完全二叉树和满二叉树等类型。平衡树如AVL树和红黑树，确保了操作的高效性。堆通常用于优先队列的实现，分为最大堆和最小堆。 图数据结构用于表示对象之间的复杂...
第九章（2）.次优查找树
风吹无迹雨落无痕
04-26 550
//顺序查找以及折半查找最优的前提是各记录被查找的概率相等！而显示中很多地方，各记录的查找概率不等！//在概率不等的情况下，取最小的二叉树为静态最优查找树(Static Optimal Search Tree),//由于构造静态最优查找树花费的时间代价较高，所以有了次优查找树(Nearly Optimal Search Tree)#include #include #include #includ
静态树表（次优查找树）（第九章 P222 算法9.3,9.4）
但行好事，莫问前程
04-13 997
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */ #include<malloc.h> /* malloc()等 */ #include<stdio.h> /* EOF(=...
次优查找树
静水流深
07-23 5287
/* 构造“次优查找树”，使树的带权路径近似达到最小 难点在于构造树的过程，怎样来递归寻找根节点，并且逐序形成次优查找树
次优查找树的原理是什么？
随心的专栏
08-14 8353
原文地址：http://www.zhihu.com/question/21063814为什么有：次优查找树？ （二叉）查找树：对有序数据进行查找，任何一种基于比较的查找策略都可以用一棵二叉树表示。每次查找过程就是从这棵二叉树的根节点出发，每次根据比较结果决定是走向左子树还是右子树还是停下来（因为已经找到了）。查找树的效率：如果你又已知了每个元素可能被查找的概率，你就可以对一棵查找树计算它的期望比较
次优查找树（Nearly Optimal Search Tree)
kang___xi的博客
08-05 1330
静态树表的查找          对于有序表的静态查找，有两种常见的方法，一是折半查找，也就是通常所说的二分法；另外一种是次优查找树。折半查找比较简单，这里就不说了，主要是讲讲次优查找树的建立，以及查找。        说到次优查找树，很多人就会想为什么是“次优”呢，那最优呢？最优查找树确实是存在的，但是因为它的时间复杂度达到了O(n^6）,所以在实际应用中很少使用。而次优查找树虽然平均查找次
【数据结构】最佳查找树
最新发布
weixin_62466076的博客
06-30 513
外部路径长度：由根结点到二叉树所有外部结点的路径长度的 总和为二叉树的外部路径长度En。内部路径长度：由根结点到二叉树的所有内部结点的路径长度 的总和为二叉树的内部路径长度In。动态规划：一棵最佳查找树的所有子树都是最佳查找树。取最小值的查找树就是最佳查找树。
【动态规划】最优二叉搜索树——算法设计与分析
友人帐_的博客
02-10 6614
介绍了最优二叉搜索树问题及其相关概念。并按照动态规划求解的基本步骤给出了算法策略，并进行了复杂度分析。
数据结构之二叉搜索树
weixin_56054625的博客
09-19 906
所以实际中搜索二叉树，极端情况下没有办法保证效率，所以后面会对搜索二叉树进一步扩展延申:AVLTree,红黑树.他们对搜索二叉树，左右高度提出了要求，非常接近完全二叉树，他们的效率可以达到O(logN)对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即。再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是。·为键值对构造二叉搜索树，注意：二叉搜索树需要比较，a. 树为空，则直接插入。
9.哈夫曼树
知其然，知其所以然
04-01 1088
1.什么是哈夫曼树？（What） 2.为什么需要学哈夫曼树？（Why） 3.如何学好哈夫曼树？（How）
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值