次优二叉树

在有序序列的查找中，如果各个元素的查找概率都是一样的，那么二分查找是最快的查找算法，但是如果查找元素的查找概率是不一样的，那么用二分查找就不一定是最快的查找方法了，可以通过计算ASL来得知。

所以基于这种查找元素概率不想等的有序序列，可以通过构造最优二叉树的方法，使得该二叉树的带权路径长度最小，这样的二叉树的构造代价是非常大的，所以用一种近似的算法，构造次优查找树，该树的带权路径长度近似达到最小。

次优查找数的算法描述如下

已知一个序列：（r_l,r_l+1,……，r_h），递增有序

它对应的权值为：(w_l,w_l+1,……，w_h)

定义：

取△Pi最小的那个元素i作为根，然后分别对子序列（r_l,r_l+1,……，r_i-1）和（r_i+1,r_i+2,……，r_h）同样构造次优查找树，并分别作为i的左子树和右子树

在计算△Pi时，实际上就是计算元素i前面的元素的权值之和与元素i后面的元素的权值之和的差值。如果对每一个元素都要这样计算就有很多重复计算，为了提高效率，我们引入“累计权值和”

从上面这个公式可以看出，我们只要一次性地求出所有元素的sw_i值并保存起来，以后每次求 △Pi就只要查表中对应的四个sw值进行计算就可以了。

我们先来看看下面这个例子：

关键字	A	B	C	D	E	F	G	H	I
权值	1	1	2	5	3	4	4	3	5
j	1	2	3	4	5	6	7	8	9
swj	1	2	4	9	12	16	20	23	28
△Pj	27	25	22	15	7	0	8	15	23
（根）						↑i
△Pj	11	9	6	1	9		8	1	7
（根）				↑i				↑i
△Pj	3	1	2		0		0		0
（根）		↑i			↑i		↑i		↑i
△Pj	0		0
（根）	↑i		↑i

#include <iostream>  
#include <cmath>  
using namespace std;  
  
typedef struct treenode  
{  
    char data;  
    int weight;  
    treenode *left;  
    treenode *right;  
}Treenode,*Treep;  
  
//初始化二叉树  
void init_tree(Treep &root)  
{  
    root=NULL;  
    cout<<"初始化成功!"<<endl;  
}  
  
//创建二叉树  
void SecondOptimal(Treep &rt, char R[],int sw[], int low, int high)  
{  
    //由有序表R[low....high]及其累积权值表sw(其中sw[0]==0)递归构造次优查找树T  
    int i=low;  
    int min = fabs(sw[high] - sw[low]);  
    int dw = sw[high] + sw[low-1];  
    for(int 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]);  
        }  
    }  
    rt=new Treenode;  
    rt->data=R[i];        //生成节点  
    if(i==low)            //左子树为空  
        rt->left = NULL; 
    else                //构造左子树  
        SecondOptimal(rt->left, R, sw, low, i-1);  
  
    if(i==high)            //右子树为空  
        rt->right = NULL;
    else                //构造右子树  
        SecondOptimal(rt->right, R, sw, i+1, high);  
return 1;
}//SecondOptimal  
  
//前序遍历二叉树  
void pre_order(Treep rt)  
{  
    if(rt)  
    {  
        cout<<rt->data<<"  ";  
        pre_order(rt->left);  
        pre_order(rt->right);  
    }  
}  
  
//中序遍历二叉树  
void in_order(Treep rt)  
{  
    if(rt)  
    {  
        in_order(rt->left);  
        cout<<rt->data<<"  ";  
        in_order(rt->right);  
    }  
}  
  
//后序遍历二叉树  
void post_order(Treep rt)  
{  
    if(rt)  
    {  
        post_order(rt->left);  
        post_order(rt->right);  
        cout<<rt->data<<"  ";  
    }  
}  
  
//查找二叉树中是否存在某元素  
int seach_tree(Treep &rt,char key)  
{  
    if(rt==NULL)   
        return 0;   
    else   
    {   
        if(rt->data==key)   
        {  
            return 1;  
        }  
        else  
        {  
            if(seach_tree(rt->left,key) || seach_tree(rt->right,key))  
                return 1;    //如果左右子树有一个搜索到，就返回1  
            else  
                return 0;    //如果左右子树都没有搜索到，返回0  
        }  
    }  
}