[算法 笔记] 查找二叉树上任意两个结点的最近共同祖先（更新版本）

#include <stdio.h>
#include <stdlib.h> // for calloc(), free()
#include <assert.h> // for assert()

/* 2013.7.12
 * 问题：设计一个算法，找出二叉树上任意两个结点的最近共同父节点。
 * PS. 结点中数据均不同
 */
typedef struct TreeNode TreeNode;
typedef struct ListNode ListNode;

struct TreeNode
{
    int      m_nValue;
    TreeNode *m_pLeft;
    TreeNode *m_pRight;
};

#define DEBUG 0

struct ListNode
{
#if DEBUG
    int         m_nValue;       // for test.
#else
    TreeNode    *m_pData;
#endif
    ListNode    *m_pNext;
};

struct ListHead
{
    ListNode    *m_pStart;  // 指向开始结点
    ListNode    *m_pEnd;    // 指向末尾结点
};

typedef struct ListHead ListHead;

// Construct lookup tree.
void InsertNodeToTree( TreeNode **pStart, int value  )
{
    if ( NULL == *pStart )
    {
        TreeNode *pCur = (TreeNode *) calloc( 1, sizeof(TreeNode) );
        if ( pCur == NULL )
        {
            printf( "Error for calloc.
" );
            return;
        }

        pCur->m_nValue = value;
        pCur->m_pLeft  = NULL;
        pCur->m_pRight = NULL;
        *pStart = pCur;
    }
    else
    {
        TreeNode *pCur = *pStart;

        if ( pCur->m_nValue > value )
        {
            InsertNodeToTree( &pCur->m_pLeft, value );
        }
        else if ( pCur->m_nValue < value )
        {
            InsertNodeToTree( &pCur->m_pRight, value );
        }
        else
        {
            printf( "The value is in tree.
" );
        }
    }
}

// Output the tree data.
void InOrder( TreeNode *pStart )
{
    if ( pStart != NULL )
    {
        if ( pStart->m_pLeft != NULL )
        {
            InOrder( pStart->m_pLeft );
        }

        printf( "%d, ", pStart->m_nValue );

        if ( pStart->m_pRight != NULL )
        {
            InOrder( pStart->m_pRight );
        }
    }
}

// Destroy the tree
void DestroyTree( TreeNode **pStart )
{
    if ( *pStart != NULL )
    {
        TreeNode *pCur = *pStart;
        if ( pCur->m_pLeft != NULL )
            DestroyTree( &pCur->m_pLeft );

        if ( pCur->m_pRight != NULL )
            DestroyTree( &pCur->m_pRight );

        free( pCur );
        pCur = NULL;
    }
}

// 正序插入结点。
void CreateListHead( ListHead **pStart )
{
    ListHead *pCur = (ListHead *)calloc( 1, sizeof(ListHead) );
    assert( pCur != NULL );
    pCur->m_pEnd    = NULL;
    pCur->m_pStart  = NULL;
    *pStart = pCur;
}

// Destroy list
void DestroyList( ListHead **pStart )
{
    ListNode *pCur = (*pStart)->m_pStart;
    ListNode *pTmp = NULL;

    while ( pCur != NULL )
    {
        pTmp = pCur;
        pCur = pCur->m_pNext;
        free( pTmp );
        pTmp = NULL;
    }

    free( *pStart );
    *pStart = NULL;
}

// Insert node to list.
#if DEBUG
void InsertNodeToList( ListHead *pStart, int value )    // for test
#else
void InsertNodeToList( ListHead *pStart, TreeNode *value )
#endif

{
    ListNode *pCur = (ListNode *) calloc( 1, sizeof(ListNode) );
    assert( pCur != NULL );
#if DEBUG
    pCur->m_nValue = value; // for test
#else
    pCur->m_pData  = value;
#endif
    pCur->m_pNext  = NULL;
    if ( pStart->m_pStart == NULL )
    {
        pStart->m_pStart    = pCur;
        pStart->m_pEnd      = pCur;
    }
    else
    {
        // Insert node to end.
        pStart->m_pEnd->m_pNext = pCur;
        pStart->m_pEnd          = pCur;
    }
}

void OutputList( ListHead *pStart )
{
    ListNode *pCur = pStart->m_pStart;

    while ( pCur != NULL )
    {
#if DEBUG
        printf( "%d, ", pCur->m_nValue );   // for test
#else
        printf( "%d, ", pCur->m_pData->m_nValue );
#endif
        pCur = pCur->m_pNext;
    }
}
#if DEBUG
void TestTree()
{
    int arry[] = {  12, 10, 11, 9, 14, 13, 15 },
                 index = 0,
                 nlen = 0;
    TreeNode *pRoot = NULL;

    nlen = sizeof(arry) / sizeof(int);
    for ( ; index < nlen; ++index )
        InsertNodeToTree( &pRoot, arry[index] );

    InOrder( pRoot );
    DestroyTree( &pRoot );
}


void TestList()
{
    int index = 0, nlen = 12;
    ListHead *pStart = NULL;

    CreateListHead( &pStart );
    for ( ; index < nlen; ++index )
    {
        InsertNodeToList( pStart, index );
    }
    OutputList( pStart );
    DestroyList( &pStart );
}
#endif

/* 2013.7.13
 * 解决问题部分：
 */
int IsInTree( TreeNode *pStart, int value, ListHead *pHead )
{
    if ( pStart != NULL )
    {
        if ( pStart->m_nValue == value )
        {
            InsertNodeToList( pHead, pStart );
            return 1;
        }

        if ( pStart->m_nValue > value
                && pStart->m_pLeft != NULL
                && IsInTree( pStart->m_pLeft, value, pHead ) == 1)
        {
            InsertNodeToList( pHead, pStart );
            return 1;
        }

        if ( pStart->m_nValue < value
                && pStart->m_pRight != NULL
                && IsInTree( pStart->m_pRight, value, pHead ) == 1)
        {
            InsertNodeToList( pHead, pStart );
            return 1;
        }
    }

    return 0;
}

int LengthList( ListHead *pStart )
{
    int cnt = 0;
    ListNode *pCur = pStart->m_pStart;

    assert( pStart != NULL );

    for ( ; pCur != 0; ++cnt, pCur = pCur->m_pNext );

    return cnt;
}

// 查找两个了链表第一个交点。若没有则返回NULL。
TreeNode* LookForFirstIntersection( ListHead *ph1, ListHead *ph2 )
{
    ListNode *p1Cur = ph1->m_pStart,
              *p2Cur = ph2->m_pStart;
    int nlen1 = 0,
        nlen2 = 0,
        diff = 0;

    assert( ph1 != NULL && ph2 != NULL );
    nlen1 = LengthList( ph1 );
    nlen2 = LengthList( ph2 );

    // 长的链表先走两个链表之差的长度。
    if ( nlen1 > nlen2 )
    {
        diff = nlen1 - nlen2;
        for ( ; diff > 0; --diff, p1Cur = p1Cur->m_pNext );
    }
    else
    {
        diff = nlen2 - nlen1;
        for ( ; diff > 0; --diff, p2Cur = p2Cur->m_pNext );
    }

    while ( p2Cur != NULL && p1Cur != NULL )
    {
        if ( p1Cur->m_pData == p2Cur->m_pData )
            return p1Cur->m_pData;
        p1Cur = p1Cur->m_pNext;
        p2Cur = p2Cur->m_pNext;
    }

    return NULL;
}

// 共同父节点。若其中一个节点是另一个结点的子节点，则输出这个节点。
int RecentCommonAncestor( TreeNode *pStart, int lhs, int rhs )
{
    ListHead *plHead = NULL,
              *prHead = NULL;
    TreeNode *pCur = NULL;

    CreateListHead( &plHead );
    CreateListHead( &prHead );

    if ( IsInTree( pStart, lhs, plHead ) == 1
            && IsInTree( pStart, rhs, prHead ) == 1 )
    {
        printf( "
The path of lhs is 
" );
        OutputList( plHead );
        printf( "
The path of rhs is 
" );
        OutputList( prHead );

        // lookup for the first node which two lists intersect.
        pCur = LookForFirstIntersection( plHead, prHead );
    }

    DestroyList( &plHead );
    DestroyList( &prHead );

    if ( pCur != NULL )
        return pCur->m_nValue;
    else
        return 0;
}

void TestRCA()
{
    int arry[] = {  12, 10, 11, 9, 14, 13, 15 },
                 index = 0,
                 nlen = 0,
                 rhs = 9, lhs = 17;
    TreeNode *pRoot = NULL;

    nlen = sizeof(arry) / sizeof(int);
    for ( ; index < nlen; ++index )
        InsertNodeToTree( &pRoot, arry[index] );

    printf( "
The data in tree is 
" );
    InOrder( pRoot );

    index = RecentCommonAncestor( pRoot, lhs, rhs );
    printf( "
The values of %d and %d ", lhs, rhs );
    if ( index == 0 )
        printf( "do not have most Recent Common Ancestor.
" );
    else
        printf( "have most Recent Common Ancestor: %d.
", index );

    DestroyTree( &pRoot );
}

int main()
{
#if DEBUG
    printf( "First, we test Tree:

" );
    TestTree();

    printf( "

Second, we test list:

" );
    TestList();
#endif

    TestRCA();

    return 0;
}

　　以前写的时候忘记将思路讲述一下，今天补充下。思路：这里要是基于树的递归结构。在遍历树的过程利用链表将查询节点所经过的路径用链表记录下来（所查节点为开始节点，根节点为末尾戒点），通过两次遍历分别得到两个路径链表。考虑到由于根节点作为链表的末尾节点，那么它们的共同最近最先节点则是两个链表的第一个交叉节点，因此这个问题也就转化为查找两个链表的第一个相交节点。

　　有关如何有效的记录路径链表：当在树中查找到节点时，返回true，并将节点插入到链表中。这里借助了函数调用过程中栈的使用，即当该函数没有退出时，当前局部数据还在栈中。例如，在递归过程中，当前节点的左右子树没有推出的时候，则在该层函数中，当前节点的数据还保存在系统栈中。