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

最新推荐文章于 2021-05-25 04:49:12 发布
最新推荐文章于 2021-05-25 04:49:12 发布
阅读量948 收藏
点赞数
分类专栏： Algorithm_BinayTree 文章标签： c++ n2 iostream string 算法
本文介绍了一种使用动态规划求解最优二叉搜索树的算法，并提供了完整的C++实现代码。该算法通过预处理概率数据并计算不同子树的最佳根节点来最小化平均查找成本。

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

程序在VC++6.0下编译通过

   

      1 
    #include 
    <
    iostream
    >
    

      2 
    #include 
    <
    fstream
    >
    

      3 
    #include 
    <
    string
    >
    

      4 
    #include 
    <
    limits
    >
    

      5 
    

      6 
     
    using
     
    namespace
     std;

      7 
    

      8 
    
    const
     
    string
     INFILE 
    =
     
    "
    in.txt
    "
    ;    
    //
     存放“输入数据”的文件
    

      9 
    
    const
     
    string
     OUTFILE 
    =
     
    "
    out.txt
    "
    ;    
    //
     存放“输出数据”的文件
    

     10 
    
    const
     
    int
     N 
    =
     
    7
    ;    
    //
    结点数
    

     11 
    
    const
     
    double
     MAX 
    =
     numeric_limits
    <
    double
    >
    ::max();    
    //
    double的最大值
    

     12 
    
    const
     
    double
     MAXMAX 
    =
     numeric_limits
    <
    long
    >
    ::max();    
    //
    double的最大值
    

     13 
    
    

     14 
    
    double
     p[N
    +
    2
    ];        
    //
     p[i]为结点i被访问的概率
    

     15 
    
    double
     q[N
    +
    2
    ];        
    //
     q[i]为“虚结点”i被访问的概率

     16 
    
    //
    double e[(N+2)*(N+2)];        
    //
     e，用来存放子树（i，j）的期望代价
    

     17 
    
    double
     e[N
    +
    2
    ][N
    +
    2
    ];

     18 
    
    //
    double w[(N+2)*(N+2)];        
    //
     w，用来存放子树（i，j）的所有结点（包括虚结点）的p、q之和
    

     19 
    
    double
     w[N
    +
    2
    ][N
    +
    2
    ];

     20 
    
    //
    int root[(N+2)*(N+2)];    
    //
     root，用来跟踪root的
    

     21 
    
    int
     root[N
    +
    2
    ][N
    +
    2
    ];

     22 
    

     23 
    

     24 
    
    //
    void optimalBst(double *p, double *q, int n)
    

     25 
    
    void
     optimalBst(
    void
    )

     26 
    {

     27 
        
    int
     i,j,l,r;    
    //
     i,j用来标记“子树（i，j）”；l用来标记“步长”；r用来标记子树的根节点（动态规划的“选择”）

     28 
    

     29 
        
    //
    这是个很boundary的case：当j=i-1的时候，“子树（i，j）”实际上是“虚结点i-1”*/
    

     30 
    
        
    for
    (i
    =
    1
    ; i
    <=
    N
    +
    1
     ; 
    ++
    i)

     31 
        {

     32 
            e[i][i
    -
    1
    ] 
    =
     q[i
    -
    1
    ];

     33 
            w[i][i
    -
    1
    ] 
    =
     q[i
    -
    1
    ];

     34 
        }

     35 
    

     36 
        
    //
     用“动态规划”方法，自底向上构造“最优二叉搜索树”的解
    

     37 
    
        
    for
    (l
    =
    1
     ; l
    <=
    N ; 
    ++
    l)    
    //
     步长l从小到大
    

     38 
    
        {

     39 
            
    for
    (i
    =
    1
     ; i
    <=
    N
    -
    l
    +
    1
     ; 
    ++
    i)    
    //
    步长为l的情况下，i的范围是1到N-l+1
    

     40 
    
            {

     41 
                j 
    =
     i
    +
    l
    -
    1
    ;    
    //
     此时步长为l，j的值为i+l-1
    

     42 
    
                e[i][j] 
    =
     MAX;

     43 
                w[i][j] 
    =
     w[i][j
    -
    1
    ] 
    +
     p[j] 
    +
     q[j];    
    //
     对于“子树（i，j）”来说，不管树形是什么样的，w[i,j]的值都是固定的

     44 
    

     45 
                
    //
     在i--j中，选择一个r作为“最佳根节点”
    

     46 
    
                
    double
     temp 
    =
     MAX;

     47 
                
    for
    (r
    =
    i ; r
    <=
    j; 
    ++
    r)

     48 
                {

     49 
                    temp 
    =
     e[i][r
    -
    1
    ] 
    +
     e[r
    +
    1
    ][j] 
    +
     w[i][j];

     50 
                    
    if
    (temp 
    <
     e[i][j])

     51 
                    {

     52 
                        e[i][j] 
    =
     temp;

     53 
                        root[i][j] 
    =
     r;

     54 
                    }

     55 
                }

     56 
            }

     57 
        }    

     58 
    

     59 
    

     60 
    }

     61 
    

     62 
    
    int
     main()

     63 
    {

     64 
        
    int
     i,j;

     65 
        ifstream fIn(INFILE.c_str());        
    //
    文件“读入流”
    

     66 
    
        ofstream fOut(OUTFILE.c_str());        
    //
    文件“输出流”

     67 
        

     68 
        
    //
    从文件读入输入数据
    

     69 
    
        i
    =
    1
    ;

     70 
        
    while
    (
    !
    fIn.eof())

     71 
        {

     72 
            
    if
    (i
    <=
    N)

     73 
            {

     74 
                fIn
    >>
    p[i];

     75 
            }

     76 
            
    else
    

     77 
            {

     78 
                fIn
    >>
    q[i
    -
    N
    -
    1
    ];

     79 
            }

     80 
            
    ++
    i;

     81 
        }

     82 
    

     83 
        
    //
     用“动态规划”计算“最优二叉搜索树”

     84 
        
    //
    optimalBst(p,q,N);
    

     85 
    
        optimalBst();

     86 
    

     87 
        
    //
     打印结果
    

     88 
    
        
    for
    (i
    =
    0
     ; i
    <=
    N
    +
    1
     ; 
    ++
    i)

     89 
        {

     90 
            
    for
    (j
    =
    0
     ; j
    <=
    N
    +
    1
     ; 
    ++
    j)

     91 
            {

     92 
                fOut
    <<
    "
    e[
    "
    <<
    i
    <<
    "
    ,
    "
    <<
    j
    <<
    "
    ] = 
    "
    <<
    e[i][j]
    <<
    endl;

     93 
            }

     94 
        }

     95 
        fOut
    <<
    endl
    <<
    endl;

     96 
        
    for
    (i
    =
    0
     ; i
    <=
    N
    +
    1
     ; 
    ++
    i)

     97 
        {

     98 
            
    for
    (j
    =
    0
     ; j
    <=
    N
    +
    1
     ; 
    ++
    j)

     99 
            {

    100 
                fOut
    <<
    "
    w[
    "
    <<
    i
    <<
    "
    ,
    "
    <<
    j
    <<
    "
    ] = 
    "
    <<
    w[i][j]
    <<
    endl;

    101 
            }

    102 
        }

    103 
        fOut
    <<
    endl
    <<
    endl;

    104 
        
    for
    (i
    =
    0
     ; i
    <=
    N
    +
    1
     ; 
    ++
    i)

    105 
        {

    106 
            
    for
    (j
    =
    0
     ; j
    <=
    N
    +
    1
     ; 
    ++
    j)

    107 
            {

    108 
                fOut
    <<
    "
    root[
    "
    <<
    i
    <<
    "
    ,
    "
    <<
    j
    <<
    "
    ] = 
    "
    <<
    root[i][j]
    <<
    endl;

    109 
            }

    110 
        }

    111 
        

    112 
        cout
    <<
    "
    大丈夫、萌大奶，去
    "
    <<
    OUTFILE
    <<
    "
    里查看结果吧少年！
    "
    <<
    endl;

    113 
        cout
    <<
    MAXMAX
    <<
    endl;

    114 
    

    115 
        
    return
     
    0
    ;

    116 
    }
分类: 算法
C++ 最优二叉搜索树
Silence的程序实验室
05-04 1621
//最优二叉查找树，利用动态规划实现 #include using namespace std; void Optimal_BST(double *p,double *q,int length,double (*e)[20],int (*root)[20]) { int i,j,k,r; double t; double w[20][20]={0}; for(i=1;i<=length+1
动态规划-最优二叉搜索树
天天开心
10-15 2047
一.二叉搜索树定义 （1）或为一棵空树 （2）或者是具有以下性质的一棵二叉树 --若左子树不为空，则左子树的结点值均小于根结点的值。 --若右子树不为空，则右子树的结点值均大于根结点的值。 --左右子树均为二叉搜索树。 (a)和(b)均为二叉搜索树，k表示实际存在的结点，d表示虚结点。（k1<k2<k3<k4&lt...
最优二叉查找树的期望搜索代价（动态规划)C++实现
pleasetojava
11-03 462
// 最优二叉查找树的期望搜索代价.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;limits&gt; #define N 100 using n...
【动态规划】最优二叉搜索树（C++）
穹的博客
05-29 3920
文章目录一、关于最优二叉搜索树1. 问题描述：2. 问题分析：二、算法实现1. 自底向上 非递归 的动态规划2. 运行结果展示 一、关于最优二叉搜索树 1. 问题描述： 给定一个由n个互异的关键字组成的有序序列K={k1<k2<k3<,……,<kn}和它们被查询的概率P={p1,p2,p3,……,pn}，要求构造一棵二叉查找树T，使得查询所有元素的总代价最小。 对于一个搜索树，当搜索的元素在树内时，表示搜索成功。当不在树内时，表示搜索失败，用一个“虚叶子节点（虚拟键）”来表示搜索失
动态规划--最优二叉查找树
weixin_33910385的博客
01-08 327
　　刚刚看到这个题目的时候，赶紧有点难呀~ 但是看了网上别人的两篇博客后，发现当把那些概念和方法弄懂后，实现起来还是非常简单的！ 　　额。。本来想写点什么的，但是看到别人的都写得那么详细了，那我就免了吧。 　　主要参考博客： 　　http://www.cnblogs.com/Anker/archive/2013/03/13/2958488.html 　　http://www.cnblogs...
动态规划-最优二叉搜索树-公式推导
while_black的博客
04-30 484
#include <iostream> #include<bits/stdc++.h> using namespace std; const int MaxVal = 9999; const int n = 5; //搜索到根节点和虚拟键的概率 double p[n + 1] = {0, 0.15, 0.1 , 0.05 , 0....
最优二叉搜索树的动态规划算法
04-23
在这个问题中，我们用C#语言实现了动态规划算法来构建最优二叉搜索树。动态规划是一种解决最优化问题的有效方法，它将大问题分解为小问题，然后通过构建子问题的最优解来获得原问题的最优解。 首先，我们需要理解...
动态规划之最优二叉搜索树
GailyYelp的博客
03-26 2317
目录 最优二叉搜索树简介 举例以及详细分析 代码块 测试结果 最优二叉搜索树简介1、概念引入　　基于统计先验知识，我们可统计出一个数表（集合）中各元素的查找概率，理解为集合各元素的出现频率。比如中文输入法字库中各词条（单字、词组等）的先验概率，针对用户习惯可以自动调整词频——所谓动态调频、高频先现原则，以减少用户翻查次数。这就是最优二叉查找树问题：查找过程中键值比较次数最少，或者说希望用最少的键值比
最优二叉查找树—动态规划C++
qq_45644525的博客
12-26 9986
最优二叉查找树欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdo
c语言实现的用动态规划实现最优二叉查找树
06-13
c语言实现的用动态规划实现最优二叉查找树，，，具体参见附件，2.txt中的内容为： 5 0.15 0.10 0.05 0.10 0.20
最优二叉搜索树
06-26
最优二叉搜索树，计算机算法设计与分析的一个题目
动态规划之最优二叉搜索树的结构 C++实现
liu798675179的专栏
11-08 2676
动态规划之最优二叉搜索树的结构 C++实现原理根据每个元素出现的频率，对应一个概率值，计算期整个二叉树的期望搜索代价，确定最优二叉树的结构。源代码#include <iostream> #include <utility> #include <vector>using namespace std;//Probability. vector<double> temp_dblP = { 0.0,0.15
最优二叉搜索树探究【C/C++】
gc.collect()
10-22 2107
简述 什么是二叉树 下面的这棵树，就是二叉搜索树 相对于什么最优 这里考虑的是ASL（average search length）平均搜索长度。即根据概率来生成ASL最小的搜索树。 到这里，最优二叉搜索树的概念就已经清楚了。 解决方法 如果是递归来搜索也是可以的，但是很明显需要做很多的重复的计算。 为了解决这个问题，所以我们采用动态规划来做，很明显，这样能降低计算的复杂度。 处理方法：动态...
数据结构与算法分析-C++描述 第10章 算法设计技巧（动态规整之最优二叉搜索树）
qq_37172182的博客
05-18 378
算法设计技巧三：动态规整（dynamic programming） 在上篇分治算法中看到，一个可以被数学上递归表示的问题也可以表示成递归算法，在许多情况下对朴素的穷举搜索得到显著的性能改进。由于编译器常常不能正确对待递归算法，结果产生低效的程序。将递归算法改写成非递归的方式，将子问题的答案系统地记录在一张表中，这种算法技巧称为动态规整。 用表代替递归： 使用递...
动态规划—最优二叉搜索树
云那边是海的专栏
08-30 2015
介绍了OBST 树的院里，构造，以及源码
c语言动态规划最优二叉搜索树,最优二叉搜索树（动态规划）
weixin_35666711的博客
05-25 1144
#include#include#include#include#includeenum:int{MAXVALUE=999};templateclassBestTree{private:T**root;//记录给定子树的根节点.Ty**e;//记录子树概率总和.Type**w;//记录子树代价总和.std::vectorp;std::vectorq;intpLengt...
最优二叉查找树_动态规划
weixin_30254435的博客
12-05 218
原问题是给出各个节点和各个节点的被查找概率，然后构造一棵各个节点平均被查找比较次数最小的树，则该问题可以用动态规划来解决 示例如下 推广到一般的情况，并设T(i, j)是由记录{ri, …, rj}(1≤i≤j≤n)构成的二叉查找树，C(i, j)是这棵二叉查找树的平均比较次数，有下列分析 观察这个表，可知可知左边的表的第一行的第四列就是我们要求的最优平...
动态规划最优二叉搜索树C语言,算法 – 动态规划：最优二叉搜索树
weixin_42303112的博客
05-23 1195
好吧,我希望有人可以向我解释一下.我正在攻读决赛,我无法解决问题.问题是动态编程;构造最优二叉搜索树(OBST).我理解一般的动态编程和特别是这个问题的概念,但我不明白这个问题的递归形式.我得到的是,我们正在为这些节点中不断增加的子集构建最优二叉搜索树,并在我们继续时将答案保存在表中以避免重新计算.当你在a_ {k}根树时,我也得到了这一点,所有来自a_ {1}到a_ {k-1}的成功节点以及它们...
动态规划法 最优二叉搜索树
最新发布
03-21
### 动态规划实现最优二叉搜索树 动态规划是一种解决复杂问题的有效方法，通过将其分解为更小的子问题来逐步求解。对于构建最优二叉搜索树（OBST），其目标是最小化平均搜索成本。以下是基于动态程序设计的算法实现及其解释。 #### 算法概述 为了找到一棵具有最小预期搜索代价的二叉搜索树，可以采用动态规划技术。该过程涉及计算不同节点作为根时的成本，并选择使总成本最低的那个配置[^1]。 #### 关键概念 - **n**: 节点总数。 - **p[i]**: 第 i 个关键字 ki 的查找概率。 - **q[i]**: 在区间 (ki, ki+1) 中找不到任何关键字的概率。 - **e[i][j]**: 表示从第 i 到 j 构建 OBST 所需期望成本。 - **w[i][j]**: 子链表 {Ki,...Kj} 上所有 p 和 q 值之和。 #### C++ 示例代码 下面提供了一个简单的 C++ 版本的实现： ```cpp #include <iostream> #include <vector> using namespace std; void printSolution(int root[][], int n){ cout << "Roots of the optimal BST:" << endl; for (int i=0; i<=n; ++i) cout << root[i][n] << ' '; } // Function to get optimum cost and construct tree. double optCost(vector<double> &p, vector<double> &q, int n){ // Initialize tables e[][] and w[][] double e[n+2][n+1]; double w[n+2][n+1]; // Root table will store roots of subtrees optimized over different ranges. int root[n+1][n+1]; for (int i=0;i<=n;i++) { e[i][i-1]=q[i]; w[i][i-1]=q[i]; } for (int l=1;l<=n;l++){ for (int i=0;i<=n-l;i++){ int j=i+l; e[i][j]=INFINITY; w[i][j]=w[i][j-1]+p[j]+q[j]; for (int r=i;r<j;r++){ double t=e[i][r-1]+e[r+1][j]+w[i][j]; if(t<e[i][j]){ e[i][j]=t; root[i][j]=r; } } } } return e[0][n]; } int main(){ int keys[]={10,12,20}; double p[]= {0.35,0.25,0.4}; // probabilities of searching each key double q[]= {0.05,0.1,0.05,0.1}; // probabilities when not found between or outside int n=sizeof(keys)/sizeof(keys[0]); printf("Expected Cost is %.6f\n",optCost(p,q,n)); } ``` 此代码片段展示了如何利用给定的关键字集合以及它们对应的访问频率来创建一颗最优二叉搜索树[^3]。 #### JavaScript 实现 同样地，在 JavaScript 中也可以实现这一逻辑: ```javascript function buildObst(p, q, n) { let e = Array.from({ length: n + 2 }, () => new Array(n + 1).fill(0)); let w = Array.from({ length: n + 2 }, () => new Array(n + 1).fill(0)); let root = Array.from({ length: n + 1 }, () => new Array(n + 1).fill(0)); for(let i = 0; i <= n; i++) { e[i][i - 1] = q[i]; w[i][i - 1] = q[i]; } for(let L = 1; L <= n; L++) { for(let i = 0; i <= n - L; i++) { let j = i + L; e[i][j] = Infinity; w[i][j] = w[i][j - 1] + p[j] + q[j]; for(let r = i; r < j; r++) { let temp = e[i][r - 1] + e[r + 1][j] + w[i][j]; if(temp < e[i][j]) { e[i][j] = temp; root[i][j] = r; } } } } console.log('The expected search cost:', e[0][n]); function printTree(i,j){ if(j<i) return ''; else{ const k=root[i][j]; return '('+printTree(i,k-1)+','+ String.fromCharCode(k+'A'.charCodeAt()-1)+ ','+printTree(k+1,j)+')'; } } console.log(printTree(0,n)); } let p=[null,.3,.3,.4]; let q=[.2,null,.2,.2,.1]; buildObst(p,q,3); ``` 上述脚本实现了相同的动态规划策略用于寻找最佳结构并打印出来[^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值