二叉搜索树转换为双向链表

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
using namespace std;


typedef struct BinaryTreeNode
{
    int m_nValue;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
}Node ,*pNode;

/*
    递归遍历中的转换过程
    参数：处理当前结点，当前链表的最后一个结点(初始值为空)
    */
void ConvertNode(BinaryTreeNode* pNode, BinaryTreeNode** pLastNodeInList)
{
    if(pNode == NULL)
        return;
    BinaryTreeNode* pCurrent = pNode;
    //递归处理左子树
    if (pCurrent->m_pLeft != NULL)
        ConvertNode(pNode->m_pLeft,pLastNodeInList);
    //处理当前结点
    pCurrent->m_pLeft = *pLastNodeInList;    //将当前结点的左指针指向已经转换好的链表的最后一个位置
    if (*pLastNodeInList!=NULL)
        (*pLastNodeInList)->m_pRight = pCurrent;//将已转换好的链表的最后一个结点的右指针指向当前结点

    *pLastNodeInList = pCurrent;//更新链表的最后一个结点
    //递归处理当前结点的右子树
    if (pCurrent->m_pRight != NULL)
        ConvertNode(pNode->m_pRight, pLastNodeInList);
}

BinaryTreeNode* Convert(BinaryTreeNode* pRootInTree)
{
    BinaryTreeNode* pLastNodeInList = NULL;

    ConvertNode(pRootInTree, &pLastNodeInList);

    //pLastNodeInList指向双向链表的尾结点，再次遍历找到头结点
    BinaryTreeNode* pHeadOfList = pLastNodeInList;
    while(pHeadOfList != NULL && pHeadOfList->m_pLeft != NULL)
        pHeadOfList = pHeadOfList->m_pLeft;

    return pHeadOfList;
}

Node* BinaryTreeFromOrderings(int* inorder, int* preorder, int length)
{
    Node* node ;
  if(length == 0)
    {
      return NULL;
    }
 // TNode* node = new TreeNode;//Noice that [new] should be written out.
  node =(Node*)malloc(sizeof(Node));
  node->m_nValue = *preorder;
  int rootIndex = 0;
  for(;rootIndex < length; rootIndex++)//a variation of the loop
    {
      if(inorder[rootIndex] == *preorder)
      break;
    }
  node->m_pLeft = BinaryTreeFromOrderings(inorder, preorder +1, rootIndex);
  node->m_pRight = BinaryTreeFromOrderings(inorder + rootIndex + 1, preorder + rootIndex + 1, length - (rootIndex + 1));
  std::cout<<node->m_nValue<<std::endl;
  return node;
}

int main()
{
    int preorder[] = {10,6,4,8,14,12,16};
    int inorder[] = {4,6,8,10,12,14,16};

    Node* pRoot = BinaryTreeFromOrderings(inorder,preorder,7);
   // Node* pRoot = rebuild();
    Node* pList = Convert(pRoot);

    while ( pList!=NULL )
    {
        cout << pList->m_nValue <<" ";
        pList = pList->m_pRight;
    }
    cout << endl;
    return 0;
}

引用：

http://blog.csdn.net/zwhlxl/article/details/46622981
http://blog.csdn.net/zhaojinjia/article/details/9319815
http://blog.csdn.net/ljianhui/article/details/22338405
http://blog.sina.com.cn/s/blog_5a48dd2d0100zgbb.html