给定一个节点，按中序遍历顺序输出二叉树的下一个节点 （C语言）

#include <stdio.h>
#include <stdlib.h>

/*搜索二叉树 结构体*/
typedef struct TreeNode{
    int data;
    struct TreeNode *LeftNode;
    struct TreeNode *RightNode;
    /*找下一个节点的时候用*/
    struct TreeNode *ParentNode;
}TreeNode;

/*中序遍历*/
void MidSearch(TreeNode *Node)
{
    if(Node)
    {
        MidSearch(Node->LeftNode);
        printf("%d  ",Node->data);
        MidSearch(Node->RightNode);
    }
}

/*插入数据  常规写法  因为涉及到头结点的更换，用**   */
void InsertNode(TreeNode **Node,int data)
{
    /*  (*Node)在这个函数里面，是根节点  */
    TreeNode *tep = (*Node);
    if((*Node) == NULL)   /*空树，创建树*/
    {
        (*Node) = (TreeNode *)malloc(sizeof(TreeNode));
        (*Node)->data = data;
        (*Node)->LeftNode = (*Node)->RightNode = NULL;
    }
    else  /*反之，不是空树   不是空树，就不涉及根节点的更换，所以，为了书写简便，用tep代替(*Node)*/
    {
        while(1)
        {
            if(data > tep->data)  /*放右子树*/
            {
                if(tep->RightNode == NULL)
                {
                    tep->RightNode = (TreeNode *)malloc(sizeof(TreeNode));
                    /*出错点*/
                    tep->RightNode->data = data;
                    /*出错点*/
                    tep->RightNode->LeftNode = tep->RightNode->RightNode = NULL;
                    break;
                }
                tep = tep->RightNode;
                /*执行完一次判断，通过while()，继续下一次的判断*/
            }
            else
            {
               if(tep->LeftNode == NULL)
               {
                   tep->LeftNode = (TreeNode *)malloc(sizeof(TreeNode));
                   /*出错点*/
                   tep->LeftNode->data= data;
                   /*出错点*/
                   tep->LeftNode->LeftNode = tep->LeftNode->RightNode = NULL;
                   break;
               }
               tep = tep->LeftNode;
            }
        }
    }
}

/*插入数据  递归写法*/
void InsertNode1(TreeNode **Node,int data)
{
    if((*Node) == NULL)
    {
        (*Node) = (TreeNode *)malloc(sizeof(TreeNode));
        (*Node)->data = data;
        (*Node)->LeftNode = (*Node)->RightNode = NULL;
    }
    else
    {
        if(data > (*Node)->data)
            InsertNode1(&(*Node)->RightNode,data);
        else
            InsertNode1(&(*Node)->LeftNode,data);
    }
}
/*搜索二叉树   常规写法*/
TreeNode* SearchNode(TreeNode* Node,int data)
{
    while(Node)
    {
        if(data == Node->data)
            return Node;
        else if(data > Node->data)
            Node = Node->RightNode;
        else
            Node = Node->LeftNode;
    }
    return NULL;
}
/*搜索二叉树    递归写法*/
TreeNode *SearchNode1(TreeNode *Node, int data)
{
    if(Node)
    {
        if(data == Node->data)
            return Node;
        else if(data > Node->data)
            /*这个函数有参数，加return*/
            return SearchNode1(Node->RightNode,data);
        else
            return SearchNode1(Node->LeftNode,data);
    }
    return NULL;
}

/*按照中序遍历的顺序，输出搜索二叉树的当前节点的的下一个节点*/

/*输入参数：要查询的节点*/
TreeNode *FindNode(TreeNode *fNode)
{
    if(fNode == NULL)  return NULL;
    TreeNode *FindedNode = NULL;/*用来存储找到的节点*/
    /*分两种情况  情况1：有右子树的情况*/
    if(fNode->RightNode != NULL)
    {
        /*保存这个节点的右节点，如果没有找到有左节点，那么，他就是要返回的下一个节点*/
        TreeNode * Right = fNode->RightNode;
        /*找到右子树最左面的那个节点*/
        while(Right->LeftNode)
            Right = Right->LeftNode;
        FindedNode = Right;
    }
    /*情况二：没有右子树的情况  有分为两种情况*/
    if(fNode->ParentNode)   /*要查找的节点有父节点*/
    {
        /*如果他是左孩子，直接打印他的父节点*/
        if(fNode == fNode->ParentNode->LeftNode)
            FindedNode = fNode->ParentNode;
        /*如果他是右孩子，就一直向上找，直到找到 某个节点 是他 父节点 的左孩子(打印父节点)*/
        else
        {
            /*定义两个变量，用来存储向上查找时的临时量*/
            TreeNode *tep_parent = fNode->ParentNode;
            TreeNode *tep_cur    = fNode;
            while(tep_parent != NULL && tep_cur == tep_parent->LeftNode)
            {
                tep_cur = tep_parent;
                tep_parent = tep_parent->ParentNode;
            }
            FindedNode = tep_parent;
        }
    }
    return FindedNode;
}
/*销毁树   递归实现*/
void destroy(TreeNode *Node)
{
    if(Node)
    {
        destroy(Node->LeftNode);
        destroy(Node->RightNode);
        free(Node);
    }
}
int main(void)
{
    TreeNode *Node = NULL;
    TreeNode *fNode;
    TreeNode *Next;
    int data[]={6,2,8,1,5,3,4};
    int i = 0,num =7;

    for(i=0;i<num;i++)
    {
        /*插入数据  常规写法  */
         InsertNode(&Node,data[i]);
         /*插入数据  递归写法*/
 //        InsertNode1(&Node,data[i]);
    }
    /*中序遍历*/
    MidSearch(Node);

    /*搜索二叉树   常规写法*/
   fNode = SearchNode(Node,5);
    printf("\nfNode = %d ",fNode->data);
    /*搜索二叉树    递归写法*/
//    fNode = SearchNode1(Node, 4);
//    printf("\nfind=%d \n ",fNode->data);


    /*输入参数：要查询的节点*/
    Next = FindNode(fNode);
    if(Next == NULL)
        printf("fail \n");
    else
        printf("Next = %d \n",Next->data);

    /*销毁树   递归实现*/
    destroy(Node);

    return 0;
}