二元查找树转变成排序的双向链表

一网友对算法感兴趣，不知怎么得到了我的QQ号，加为好友。给我发来了微软面试题100题，让我做一做。我也正好想准备年底找工作的事儿，一举两得，就试试上面题目的难度。

    第一道题是把二元查找树转变成排序的双向链表。一开始做这些题，困难还真不少，遇到的第一个问题就是：什么是二元查找树？

    二元查找树： 它首先要是一棵二元树，在这基础上它或者是一棵空树；或者是具有下列性质的二元树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二元查找树（摘自百度百科）

     这个就很好理解了：二叉树嘛！怎么建树呢？按照题目的意思一个一个结点的加进去就OK了。这里需要注意的是：加结点时，会用到C++的“别名",或者C语言的双重指针（指向指针的指针）。这里真的就考C语言的功底了！在《高质量C++编程指南：内存管理》中有这样的知识点：

http://www.cppblog.com/xczhang/archive/2011/08/12/41411.html

指针参数：

不要让指针参数在函数体内部申请内存，如果非要指针在函数体内部申请内存，就要用指针的指针。函数的返回值不能使用栈内分配的变量地址。

    接着就是树的遍历了。我依稀记得树有三种遍历的方式，只是有些模糊了。摸索着把代码写出来，发现用递归实现时，只要改变输出的位置，自然就对应着三种不同的遍历方式：先序，中序，后序！（可参见代码的注释），而且我还意外的发现，中序遍历二元查找树就能让树中的元素按升序排列输出。后来百度之，很多博客也都是这样解释。唉！只能说明自己树的知识不牢固啊！

     好了，接下来就是把构建双向链表了。我依然百度了一段代码http://blog.youkuaiyun.com/zz198808/article/details/7883096：说来也巧，博客的主人竟然是加我QQ的人。呵呵……缘份啊！

    虽然背后议论别人不好，但我还是说，他那构建双向链表的代码变量名没定义好，说白了，名字没取好！但依然要向他致敬：毕竟是学习别人的东西！

    好了，贴代码吧：

 
/* 
 * Problem_1.cpp 
 * 
 *  Created on: 2012-8-27 
 *      Author: Administrator 
 */ 
#include<stdio.h> 
struct BSTreeNode{ 
    int value; 
    struct BSTreeNode *pLeft,*pRight; 
    BSTreeNode(){ 
        pLeft=pRight=NULL; 
    } 
}; 
//创建链表用到的两个指针 
BSTreeNode *head=NULL,*tail=NULL; 
 
//只要调整输出的位置，就分别对应着三种不同的遍历方式 
void createList(BSTreeNode *cur){ 
    cur->pLeft=tail;//把当前的root接到链表的尾部 
    if(tail!=NULL){//双向连接 
        tail->pRight=cur; 
    }else{ 
        head=cur; 
    } 
    tail=cur;//更新尾结点为当前结点，或者说：尾结点后移 
} 
BSTreeNode* visit(BSTreeNode *root){ 
    if(root!=NULL){ 
//      printf("%d ",root->value);//先序 
        visit(root->pLeft); 
//      printf("%d ",root->value);//中序 
        createList(root); 
        visit(root->pRight); 
//      printf("%d ",root->value);//后序 
    } 
    return root; 
} 
void addNode(BSTreeNode **root,int value){ 
    BSTreeNode *p; 
    if(NULL!=*root){ 
        if(value>(*root)->value){ 
            addNode(&((*root)->pRight),value); 
        }else if(value<(*root)->value){ 
            addNode(&((*root)->pLeft),value); 
        }else{ 
            printf("the node with value %d is in the tree!\n",value); 
        } 
    }else{ 
        p=new BSTreeNode(); 
        p->value=value; 
        *root=p; 
    } 
} 
int main(){ 
    BSTreeNode *root=NULL; 
    int data[]={10,6,14,4,8,12,16}; 
    for(int i=0;i<7;i++){ 
        addNode(&root,data[i]); 
    } 
    visit(root); 
//output 其实只选择一种即可，如果选择tail，则是降序输出，选择head，则是升序输出
    while(tail!=NULL){ 
        printf("%d ",tail->value); 
        tail=tail->pLeft; 
    } 
prinft("\n");
    while(head!=NULL){ 
        printf("%d ",head->value); 
        head=head->pRight; 
    } 
    return 0; 
} 

题目不难，但是很基础，很能考验出编程的功底和水平！接着往下学习吧！

本文出自 “每天进步一点点” 博客，请务必保留此出处http://sbp810050504.blog.51cto.com/2799422/974867

跟编程之美中的题目很类似，如下：

 

 分析：

1：由于要求链表是有序的，可以借助二叉树中序遍历，因为中序遍历算法的特点就是从小到大访问结点。当遍历访问到根结点时，假设根结点的左侧已经处理好，只需将根结点与上次访问的最近结点（左子树中最大值结点）的指针连接好即可。进而更新当前链表的最后一个结点指针。

2：由于中序遍历过程正好是转换成链表的过程，即可采用递归处理

转换代码如下：

[cpp]  view plain copy print ?

1. struct BinaryTreeNode  
2. {  
3.     int m_nVlaue;  
4.     BinaryTreeNode* m_pLeft;  
5.     BinaryTreeNode* m_pRight;  
6. };  
7.   
8. /* 
9.     递归遍历中的转换过程 
10.     参数：处理当前结点，当前链表的最后一个结点(初始值为空) 
11.     */  
12. void ConvertNode(BinaryTreeNode* pNode, BinaryTreeNode** pLastNodeInList)  
13. {  
14.     if(pNode == NULL)  
15.         return;  
16.     BinaryTreeNode* pCurrent = pNode;  
17.     //递归处理左子树  
18.     if (pCurrent->m_pLeft != NULL)  
19.         ConvertNode(pNode->m_pLeft,pLastNodeInList);  
20.     //处理当前结点              
21.     pCurrent->m_pLeft = *pLastNodeInList;    //将当前结点的左指针指向已经转换好的链表的最后一个位置  
22.     if (*pLastNodeInList!=NULL)  
23.         *pLastNodeInList->m_pRight = pCurrent;//将已转换好的链表的最后一个结点的右指针指向当前结点  
24.   
25.     *pLastNodeInList = pCurrent;//更新链表的最后一个结点  
26.     //递归处理当前结点的右子树  
27.     if (pCurrent->m_pRight != NULL)  
28.         ConvertNode(pNode->m_pRight, pLastNodeInList);  
29. }  
30.   
31. BinaryTreeNode* Convert(BinaryTreeNode* pRootInTree)  
32. {  
33.     BinaryTreeNode* pLastNodeInList = NULL;  
34.   
35.     ConvertNode(pRootInTree, &pLastNodeInList);  
36.   
37.     //pLastNodeInList指向双向链表的尾结点，再次遍历找到头结点  
38.     BinaryTreeNode* pHeadOfList = pLastNodeInList;  
39.     while(pHeadOfList != NULL && pHeadOfList->m_pLeft != NULL)  
40.         pHeadOfList = pHeadOfList->m_pLeft;  
41.   
42.     return pHeadOfList;  
43. }  

测试代码如下：

创建一棵二叉排序树，可以调用http://blog.youkuaiyun.com/zhaojinjia/article/details/9314989方法生成。

[cpp]  view plain copy print ?

1. int _tmain(int argc, _TCHAR* argv[])  
2. {  
3.     int preorder[] = {10,6,4,8,14,12,16};    
4.     int inorder[] = {4,6,8,10,12,14,16};    
5.   
6.     BinaryTreeNode* pRoot = Construct(preorder,inorder,7);     
7.       
8.     BinaryTreeNode* pList = Convert(pRoot);  
9.   
10.     while ( pList!=NULL )  
11.     {  
12.         cout << pList->m_nVlaue <<" ";  
13.         pList = pList->m_pRight;  
14.     }  
15.     cout << endl;  
16.     return 0;  
17. }  

返回结果如下图所示：