C++笔试题（剑指offer 面试题5 将单向链表数据，逆向打印输出）

#ifndef F_FIND_WORK_TEST5_REVERSE_PRINTF_LIST_20171111_JHASKDFJHASF_H_
#define F_FIND_WORK_TEST5_REVERSE_PRINTF_LIST_20171111_JHASKDFJHASF_H_

#include <stdio.h>
#include "DataStructe_Stack.h"

/*
剑指offer 面试题5 (P51)
输出一个节点的头,从尾到头的输出每个节点的值

1)单向链表操作
2)栈是先进后出的结构,可以借用栈实现
3)也可以采用递归函数的方式实现
*/

template<class T>
struct FNode
{
    T tValue;
    FNode *pFNodeNext;
};

//清空节点所有数据
template<class T>
void ClearList(FNode<T> **pHead)
{
    FNode<T> *pCurNode = *pHead;
    while(*pHead)
    {
        pCurNode= (*pHead)->pFNodeNext;

        delete *pHead;
        *pHead = pCurNode;
    }

    pHead = NULL;
}

//打印数据
template<class T>
void PrintLite(FNode<T> *pHead)
{
    const char *tType= typeid(T).name();

    FNode<T> *pCurNode = pHead;
    while (pCurNode)
    {
        if (0 == strcmp(tType, "int"))
        {
            TRACE("%d, ", pCurNode->tValue);
        }
        else if (0 == strcmp(tType, "float"))
        {
            TRACE("%f, ", pCurNode->tValue);
        }

        pCurNode = pCurNode->pFNodeNext;
    }

    TRACE("\n");
}

//在节点末尾,添加数据
template<class T>
BOOL Pushback(FNode<T> **pHead, const T tValue)
{
    //创建新节点,存数据
    FNode<T> *pCurNode = new FNode<T>;
    pCurNode->tValue     = tValue;
    pCurNode->pFNodeNext = NULL;

    //如果为链表第一个数据,头结点
    if (*pHead == NULL)
    {
        *pHead = pCurNode;
    }
    else
    {
        //找到尾节点
        FNode<T> *pEndNode = *pHead;
        while(pEndNode->pFNodeNext)
        {
            pEndNode = pEndNode->pFNodeNext;
        }

        //将新创建节点设为尾节点
        pEndNode->pFNodeNext = pCurNode;
    }

    return TRUE;
}

//根据数据,删除节点
template<class T>
BOOL RemoveNode(FNode<T> **pHead, const T tValue)
{
    if((*pHead == NULL) || (pHead == NULL))
    {
        return TRUE;
    }

    FNode<T> *pDeleteNode = NULL;

    //如果需要删除的是第一个节点
    if((*pHead)->tValue == tValue)
    {
        pDeleteNode = *pHead;
        *pHead = (*pHead)->pFNodeNext;  
    }
    else
    {
        //找到需要删除节点的上一个节点
        FNode<T> *pPreNode = *pHead;
        while(pPreNode->pFNodeNext && (pPreNode->pFNodeNext->tValue != tValue))
        {
            pPreNode = pPreNode->pFNodeNext;
        }

        //将删除节点的上一个节点的pNext,指向删除节点的下一个节点
        if(pPreNode->pFNodeNext && (pPreNode->pFNodeNext->tValue == tValue))
        {
            pDeleteNode = pPreNode->pFNodeNext;
            pPreNode->pFNodeNext = pPreNode->pFNodeNext->pFNodeNext;
        }       
    }

    //释放需要删除的节点数据
    if (pDeleteNode)
    {
        delete pDeleteNode;
        pDeleteNode = NULL;
    }

    return TRUE;
}

//逆序打印数据,栈是先进后出的结构,可以借用栈实现
template<class T>
void ReversePrintLiteByStack(FNode<T> *pHead)
{
    TRACE("ReversePrintLiteByStack=>");

    FNode<T> *pCurNode = pHead;

    //用栈的方式实现
    F_DataStructeStack<T> FStractData(10);
    while (pCurNode)
    {
        //将每个数据,插入到头
        FStractData.InsertData(pCurNode->tValue, 0);
        pCurNode = pCurNode->pFNodeNext;
    }

    TraceDataBase(FStractData.GetData(), FStractData.GetCurDataSize());

    TRACE("\n");
}

//逆序打印数据,递归的方式实现
template<class T>
void ReversePrintLiteByFunc(FNode<T> *pHead)
{
    if(pHead)
    {
        if(pHead->pFNodeNext)
        {
            ReversePrintLiteByFunc(pHead->pFNodeNext);
        }

        const char *pType = typeid(T).name();

        if(0 == strcmp(pType, "int"))
        {
            TRACE("%d, ", pHead->tValue);
        }
        else if(0 == strcmp(pType, "float"))
        {
            TRACE("%f, ", pHead->tValue);
        }   
    }
}

//测试
void F_Test4_ReversePrintfList()
{
    FNode<int> *pHead = NULL;
    Pushback(&pHead, 10);
    Pushback(&pHead, 8);
    Pushback(&pHead, 20);
    Pushback(&pHead, 5);
    Pushback(&pHead, 26);
    Pushback(&pHead, 9);
    Pushback(&pHead, 4);
    Pushback(&pHead, 2);

    PrintLite(pHead);

    ReversePrintLiteByStack(pHead);

    TRACE("ReversePrintLiteByFunc=>");
    ReversePrintLiteByFunc(pHead);
    TRACE("\n");

    RemoveNode(&pHead, 10);
    RemoveNode(&pHead, 26);
    RemoveNode(&pHead, 2);
    RemoveNode(&pHead, 22);

    PrintLite(pHead);
    ClearList(&pHead);

    FNode<float> *pHeadF = NULL;
    Pushback(&pHeadF, (float)1.5);
    Pushback(&pHeadF, (float)8.658);
    Pushback(&pHeadF, (float)2.265);
    Pushback(&pHeadF, (float)22.456);

    PrintLite(pHeadF);

    ReversePrintLiteByStack(pHeadF);

    TRACE("ReversePrintLiteByFunc=>");
    ReversePrintLiteByFunc(pHeadF);
    TRACE("\n");

    ClearList(&pHeadF);
}

#endif//F_FIND_WORK_TEST5_REVERSE_PRINTF_LIST_20171111_JHASKDFJHASF_H_