剑指Offer（面试题14-18）

面试题14：调整数组顺序使奇数位于偶数前面

题目：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组后半部分。

void Reorder(int* pData,unsigned int length,bool (*func)(int))
{
    if(pData == NULL || length == 0)
        return;
    int *pBegin = pData;
    int *pEnd = pData+length-1;

    while(pBegin < pEnd)
    {
        while(pBegin < pEnd && !func(*pBegin))
            pBegin++;
        while(pBegin < pEnd && func(*pEnd))
            pEnd--;
        if(pBegin < pEnd)
        {
            int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;
        }
    }
}

bool isEven(int n)
{
    return (n & 1) == 0;
}

在上面的代码中，函数Reorder根据func的标准把数组pData分成两部分；而函数isEven则是一个具体的标准，即判断一个数是不是偶数。

面试题15：链表中倒数第k个结点

题目：输入一个链表，输出该链表中倒数第k个结点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾结点时倒数第1个结点。例如一个链表有6个结点，从头结点开始它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个结点时值为4的结点。

struct ListNode
{
    int         m_nValue;
    ListNode*   m_pNext;
};

ListNode* FindKthToTail(ListNode* pListHead,unsigned int k)
{
    if(pListHead == NULL || k == 0)
        return NULL;
    ListNode* pAhead = pListHead;
    ListNode* pBehind = NULL;

    for(unsigned int i = 0;i<k-1;++i)
    {
        if(pAhead->m_pNext != NULL)
            pAhead = pAhead->m_pNext;
        else
        {
            return NULL;
        }
    }

    pBegind = pListHead;
    while(pAhead->m_pnext!=NULL)
    {
        pAhead = pAhead->m_pNext;
        pBehind=pBehind->m_pNext;
    }
    return pBehind;
}

面试题16：反转链表

题目：定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。链表结点定义如下：

struct ListNode
{
    int         m_nKey;
    ListNode*   m_pNext;
};

ListNode* ReverseList(ListNode* pHead)
{
    ListNode* pReversedHead = NULL;
    ListNode* pNode=pHead;
    ListNode* pPrev =NULL;
    while(pNode != NULL)
    {
        ListNode* pNext = pNode->m_pNext;

        if(pNext == NULL)
            pReversedHead = pNode;

        pNode->m_pNext = pPrev;

        pPrev = pNode;
        pNode = pNext;
    }
    return pReversedHead;
}

我们至少应该想到几类测试用例对代码做功能测试：
1、输入的链表头指针是NULL。
2、输入的链表只有一个结点。
3、输入的链表有多个结点。

面试题17：合并两个排序的链表

题目：输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然是按照递增排序的。例如输入图3.7中的链表1和链表2，则合并之后的升序链表如链表3所示。链表结点定义如下：

struct ListNode
{
    int         m_nValue;
    ListNode*   m_pNext;
};

ListNode* Merge(ListNode* pHead1,ListNode* pHead2)
{
    if(pHead1 == NULL)
        return pHead2;
    else if(pHead2 == NULL)
        return pHead1;

    ListNode* pMergeHead = NULL;

    if(pHead1->m_nValue<pHead2->m_nValue)
    {
        pMergedHead = pHead1;
        pMergedHead->m_pNext = Merge(pHead1->m_pNext,pHead2);
    }
    else
    {
        pMergedHead = pHead2;
        pMergedHead->m_pNext = Merge(pHead1,pHead2->m_pNext);
    }
    return pMergedHead;
}

面试题18：树的子结构

题目：输入两棵二叉树A和B，判断B是不是A的子结构。二叉树结点的定义如下：

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

//第一步在树A中查找与根结点的值一样的结点，这实际上就是树的遍历。可以用递归的方法去遍历，也可以用循环的方法去遍历。由于递归的代码比较简洁，如果没有特别要求，采用递归代码如下：
bool HasSubtree(BinaryTreeNode* pRoot1,BinaryTreeNode* pRoot2)
{
    bool result = false;

    if(pRoot1 != NULL && pRoot2 != NULL)
    {
        if(pRoot1->m_nValue == pRoot2->m_nValue)
            result = DoesTree1HaveTree2(pRoot1,pRoot2);
        if(!result)
            result = HasSubtree(pRoot1->m_pLeft,pRoot2);
        if(!result)
            result = HasSubtree(pRoot1->m_pRight,pRoot2);
    }
    return result;
}
//在面试的时候，我们一定要注意边界条件的检查，即检查空指针。当树A或树B为空的时候，定义相应的输出。如果没有检查并做相应的处理，程序非常容易崩溃，这是面试时非常忌讳的事情。
//在上述代码中，我们递归调用HasSubtree遍历二叉树A。如果发现一结点的值和树B的结点的值相同，则调用DoesTree1HaveTree2，做第二步判断。第二步判断树A中以R为根结点的子树是不是和树B具有相同的结构。
bool DoesTree1HaveTree2(BinaryTreeNode* pRoot1,BinaryTreeNode* pRoot2)
{
    if(pRoot2 == NULL)
        return true;
    if(pRoot1 == NULL)
        return false;
    if(pRoot1->m_nValue != pRoot2->m_nValue)
        return false;

    return DoesTree1HaveTree2(pRoot1->m_pLeft,pRoot2->m_pLeft) &&
     DoesTree1HaveTree2(pRoot1->m_pRight,pRoot2->m_pRight);
}

参考资料《剑指Offer》。