面试题精选（83）：二叉树相关的问题

涉及题目描述：（BST—binary search tree，BT—binary tree）

1、BST构建

2、BT的层次遍历

3、BST的LCA（最近公共祖先）求解

4、BST 转化为有序的double link list

5、BT的LCA求解（将LCA问题转化为RMQ（上一篇blog涉及）问题求解）

 

相关分析：

 

1、2问题简单，不予分析

 

3、

对于BST，它有一个重要的性质：节点的左子树包含且只包含比它小的节点，
右子树包含且只包含比它大的节点。因此LCA的值一定在这两个节点之间。

1. 如果u<root && v<root，则去左子树搜索；

2. 如果u>root && v>root，则去右子树搜索；

3. 否则，root就是LCA

 

4、

左、右子树分别转化为double link list，然后将左子树list、root、右子树list连接成一个list，递归实现

 

5、

一、最近公共祖先(Least Common Ancestors)

对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能大。另一种理解方式是把T理解为一个无向无环图，而LCA(T,u,v)即u到v的最短路上深度最小的点。
这里给出一个LCA的例子：

例
对于T=<V,E>
V={1,2,3,4,5}
E={(1,2),(1,3),(3,4),(3,5)}

则有：
LCA(T,5,2)=1
LCA(T,3,4)=3
LCA(T,4,5)=3

 

二、RMQ问题(Range Minimum Query)

RMQ问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中下标在[i,j]里的最小值下标。这时一个RMQ问题的例子：

例
对数列：5,8,1,3,6,4,9,5,7 有：
RMQ(2,4)=3
RMQ(6,9)=6

RMQ问题与LCA问题的关系紧密，可以相互转换，相应的求解算法也有异曲同工之妙。

下面给出LCA问题向RMQ问题的转化方法。

对树进行深度优先遍历，每当“进入”或回溯到某个结点时，将这个结点的值存入数组E最后一位。同时记录结点i在数组中第一次出现的位置(事实上就是进入结点i时记录的位置)，记做R[i]。如果结点E[i]的深度记做D[i]，易见，这时求LCA(T,u,v)，就等价于求 E[RMQ(D,R[u],R[v])]，(R[u]<R[v])。

 

例如，对于第一节的例，求解步骤如下：
数列E[i]为：1,2,1,3,4,3,5,3,1
R[i]为：1,2,4,5,7
D[i]为：0,1,0,1,2,1,2,1,0

于是有：
LCA(T,5,2) = E[RMQ(D,R[2],R[5])] = E[RMQ(D,2,7)] = E[3] = 1
LCA(T,3,4) = E[RMQ(D,R[3],R[4])] = E[RMQ(D,4,5)] = E[4] = 3
LCA(T,4,5) = E[RMQ(D,R[4],R[5])] = E[RMQ(D,5,7)] = E[6] = 3

易知，转化后得到的数列长度为树的结点数的两倍加一，所以转化后的RMQ问题与LCA问题的规模同次。

代码：

#include <functional>
#include <math.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <fstream>
#include <vector>

using namespace std;

 

#define pow2(n) (1 << (n))
#define MAXN   10000
#define mmin(seq, a, b)  ((seq[a] < seq[b]) ? (a) : (b))

 

//// DP status
int fij[MAXN][100];

//// for output fij
template <typename T>
void Dp_st_print(T seq[], int n)
{
    //// 输出待RMQ的序列
    for(int i = 0; i < n; i++)
        cout<<seq[i]<<"/t";
    cout<<endl;
    //// 输出状态f[][]
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; i + (1<<j) - 1 < n; j++)
        {
            cout<<"fij["<<i<<", "<<j<<"] = "<<fij[i][j]<<"/t";
        }
        cout<<endl;
    }
    cout<<endl;
}

// RMQ(Range Minimum/Maximum Query)问题：

// 预处理:
// sparse table算法(st)
template <typename T>
void st(T seq[], int n)
{
    memset(fij, 0, 100 * MAXN * sizeof(int));
    int k = (int)(log((double)n) / log(2.0));
    ////初始状态
    for(int i = 0; i < n; i++)
        fij[i][0] = i;
    ////递推计算状态
    for(int j = 1; j <= k; j++)
    {
        for(int i = 0; i + (1 << j) - 1 < n; i++)
        {
            //
            int m = i + (1 << (j - 1));
            //fij[i][j] = seq[fij[i][j - 1]] < seq[fij[m][j - 1]] ? fij[i][j - 1] : fij[m][j - 1];
            fij[i][j] = mmin(seq, fij[i][j - 1], fij[m][j - 1]);
        }
    }
}

// 查询:
template <typename T>
int RMQ(T seq[], int i, int j)
{
    //// 用对2去对数的方法求出k
    int k = (int)(log(double(j - i + 1)) / log(2.0));
    ////
    //int t = seq[fij[i][k]] < seq[fij[j - (1 << k) + 1][k]] ? fij[i][k] : fij[j - (1 << k) + 1][k];
    int t = mmin(seq, fij[i][k], fij[j - (1 << k) + 1][k]);
    return t;
    //cout<<"RMQ("<<i<<", "<<j<<") = "<<seq[t]<<" @ pos("<<t<<")/n";
}

 

////////---------------------------------------------------

 

typedef struct node
{
    int key;
    node* left;
    node* right;
}Node, *pNode;

 

// normal output
void inorder_output(pNode root)
{
    if(root != NULL)
    {
        inorder_output(root->left);
        cout<<root->key<<"  ";
        inorder_output(root->right);
    }
}

 

// layer output
void layer_output(pNode root)
{
    queue<pNode> tq;
    pNode p;
    tq.push(root);
    tq.push(NULL);
    while(!tq.empty())
    {
        p = tq.front();
        tq.pop();
        if(NULL == p)
        {
            cout<<endl;
            if(!tq.empty())
               tq.push(NULL);
        }
        else
        {
            cout<<p->key<<" ";
            if(p->left != NULL)
                tq.push(p->left);
            if(p->right != NULL)
                tq.push(p->right);
        }
    }
}

 

//
int getheight_tree(pNode root)
{
    if(NULL == root)
        return 0;
    int lh = getheight_tree(root->left);
    int rh = getheight_tree(root->right);
    return lh > rh ? lh + 1 : rh + 1;
}

//

//
void insert_BST(pNode *root, int value)
{
    pNode tmp;
    if(NULL == *root)
    {
        tmp = (pNode)malloc(sizeof(Node));
        tmp->key = value;
        tmp->left = NULL;
        tmp->right = NULL;
        *root = tmp;
    }
    else
    {
        if(value <= (*root)->key)
            insert_BST(&(*root)->left, value);
        else
            insert_BST(&(*root)->right, value);
    }
}

 

// LCA of BST
// 对于BST，它有一个重要的性质：节点的左子树包含且只包含比它小的节点，
// 右子树包含且只包含比它大的节点。因此LCA的值一定在这两个节点之间。
//
// 1. 如果u<root && v<root，则去左子树搜索；
//
// 2. 如果u>root && v>root，则去右子树搜索；
//
// 3. 否则，root就是LCA
pNode search_LCA_BST(pNode root, pNode u, pNode v)
{
    if(NULL == root)
        return NULL;
    if(root->key >= u->key && root->key >= v->key)
        search_LCA_BST(root->left, u, v);
    else if(root->key < u->key && root->key < v->key)
        search_LCA_BST(root->right, u, v);
    else
        return root;
}

 

// append linklist2 to linklist1
pNode appendLL(pNode LL1, pNode LL2)
{
    if(NULL == LL1)
        return LL2;
    if(NULL == LL2)
        return LL1;
    ////tail
    pNode tail1 = LL1->left;
    pNode tail2 = LL2->left;

    ////join head and tail
    tail1->right = LL2;
    LL2->left = tail1;

    tail2->right = LL1;
    LL1->left = tail2;

    return LL1;
}

 

// convert BST to sorted link list
pNode BST_to_sortedlinklist(pNode root)
{
    if(NULL == root)
        return NULL;
    pNode leftLL = BST_to_sortedlinklist(root->left);
    pNode rightLL = BST_to_sortedlinklist(root->right);

    //
    root->left = root;
    root->right = root;

    //append leftLL ,root ,rightLL
    leftLL = appendLL(leftLL, root);
    leftLL = appendLL(leftLL, rightLL);

    return leftLL;
}

 

// travel link list
void list_output(pNode root)
{
    if(NULL == root)
        return;
    pNode p = root;
    cout<<p->key<<"  ";
    p = p->right;
    while(p != root)
    {
        cout<<p->key<<"  ";
        p = p->right;
    }
}

 

//// LCA --> RMQ
// 对树进行深度优先遍历，每当“进入”或回溯到某个结点时，
// 将这个结点的值存入数组E最后一位。同时记录结点i在数组中
// 第一次出现的位置(事实上就是进入结点i时记录的位置)，记做R[i]。
// 如果结点E[i]的深度记做D[i]，易见，这时求LCA(T,u,v)，
// 就等价于求 E[RMQ(D,R[u],R[v])]，(R[u]<R[v])。
// 例如，对于第一节的例一，求解步骤如下：
// 数列
// E[i]为：1,2,1,3,4,3,5,3,1
// R[i]为：1,2,4,5,7
// D[i]为：0,1,0,1,2,1,2,1,0
//
// 于是有：
// LCA(T,5,2) = E[RMQ(D,R[2],R[5])] = E[RMQ(D,2,7)] = E[3] = 1
// LCA(T,3,4) = E[RMQ(D,R[3],R[4])] = E[RMQ(D,4,5)] = E[4] = 3
// LCA(T,4,5) = E[RMQ(D,R[4],R[5])] = E[RMQ(D,5,7)] = E[6] = 3
void prepare_for_LCA(pNode root, int h, vector<int>& E, vector<int>& R, vector<int>& D)
{
    if(NULL == root)
        return;
    E.push_back(root->key);
    D.push_back(h);
    R.push_back((int)E.size());
    if(root->left != NULL)
    {
        prepare_for_LCA(root->left, h + 1, E, R, D);
        E.push_back(root->key);
        D.push_back(h);
    }
    if(root->right != NULL)
    {
        prepare_for_LCA(root->right, h + 1, E, R, D);
        E.push_back(root->key);
        D.push_back(h);
    }
}

//// get LCA by RMQ
int get_LCA_by_RMQ(int i, int j, int* E, int* R, int* D, int n)
{
    if(i > j)
        swap(i, j);
    ////fij
    st(D, n);

    ////
    return(E[RMQ(D, R[i - 1] - 1, R[j - 1] - 1)]);
}

 

int _tmain(int argc, _TCHAR* argv[])
{
    ////BST root
    pNode root_BST = NULL;
    pNode p;

    int A[] = {1,2,2,3,4,5,6,7,8,9};
    int N = sizeof(A) / sizeof(int);
    random_shuffle(A, A + N);

    ////construct BST tree
    for(int i = 0; i < N; i++)
        insert_BST(&root_BST, A[i]);
    cout<<endl<<"inorder travel:"<<endl;
    inorder_output(root_BST);
   
    cout<<endl<<"layer output:"<<endl;
    layer_output(root_BST);
   
    ////
    pNode u = (pNode)malloc(sizeof(Node));
    u->key = 9;
    pNode v = (pNode)malloc(sizeof(Node));
    v->key = 4;
    p = search_LCA_BST(root_BST, u, v);
    if(NULL == p)
        cout<<cout<<endl<<"节点 "<<u->key<<" 与节点 "<<v->key<<" 无LCA节点"<<endl;
    else
        cout<<endl<<"节点 "<<u->key<<" 与节点 "<<v->key<<" 的LCA是节点 "<<p->key<<endl;

    ////
    p = BST_to_sortedlinklist(root_BST);
    cout<<endl<<"convert to sorted link list :/n";
    list_output(p);
    cout<<endl;

    //// LCS --> RMQ
    pNode testT = (pNode)malloc(sizeof(Node));
    pNode node2 = (pNode)malloc(sizeof(Node));
    pNode node3 = (pNode)malloc(sizeof(Node));
    pNode node4 = (pNode)malloc(sizeof(Node));
    pNode node5 = (pNode)malloc(sizeof(Node));
    testT->key = 1;
    node2->key = 2;
    node3->key = 3;
    node4->key = 4;
    node5->key = 5;
    testT->left = node2;
    testT->right = node3;
    node2->left = node2->right = NULL;
    node3->left = node4;
    node3->right = node5;
    node4->left = node4->right = NULL;
    node5->left = node5->right = NULL;

    layer_output(testT);

    vector<int> E, R, D;
    prepare_for_LCA(testT, 0, E, R, D);

    int *arrE = new int[(int)E.size()];
    int *arrR = new int[(int)R.size()];
    int *arrD = new int[(int)D.size()];
    copy(E.begin(), E.end(), arrE);
    copy(R.begin(), R.end(), arrR);
    copy(D.begin(), D.end(), arrD);

    cout<<endl<<get_LCA_by_RMQ(4, 5, arrE, arrR, arrD, (int)D.size())<<endl;

    system("pause");
 return 0;
}