程序员面试题精选100题(01)－把二元查找树转变成排序的双向链表—python实现

本作品采用知识共享署名-非商业性使用-相同方式共享 3.0 Unported许可协议进行许可。允许非商业转载，但应注明作者及出处。

作者：liuyuan_jq

2011-07-13

---

题目：输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的结点，只调整指针的指向。

　　比如将二元查找树
                                            10
                                          /    \
                                        6       14
                                      /  \     /　 \
                                   　4     8  12 　  16
转换成双向链表

4=6=8=10=12=14=16。

　　分析：本题是微软的面试题。很多与树相关的题目都是用递归的思路来解决，本题也不例外。下面我们用两种不同的递归思路来分析。

　　思路一：当我们到达某一结点准备调整以该结点为根结点的子树时，先调整其左子树将左子树转换成一个排好序的左子链表，再调整其右子树转换右子链表。最近链接左子链表的最右结点（左子树的最大结点）、当前结点和右子链表的最左结点（右子树的最小结点）。从树的根结点开始递归调整所有结点。

　　思路二：我们可以中序遍历整棵树。按照这个方式遍历树，比较小的结点先访问。如果我们每访问一个结点，假设之前访问过的结点已经调整成一个排序双向链表，我们再把调整当前结点的指针将其链接到链表的末尾。当所有结点都访问过之后，整棵树也就转换成一个排序双向链表了。

参考代码：

首先我们定义二元查找树结点的数据结构如下：
    struct BSTreeNode // a node in the binary search tree
    {
        int          m_nValue; // value of node
        BSTreeNode  *m_pLeft;  // left child of node
        BSTreeNode  *m_pRight; // right child of node
    };

#!/usr/bin/env python
# -*- coding:utf-8 -*-


"""
把二元查找树转变成排序的双向链表
 题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
    
  10
  / \
 6   14
 / \ / \
4 8 12 16
    
 转换成双向链表
4=6=8=10=12=14=16。


 首先我们定义的二元查找树 节点的数据结构如下：
 struct BSTreeNode
{
  int m_nValue; // value of node
  BSTreeNode *m_pLeft; // left child of node
  BSTreeNode *m_pRight; // right child of node
};


"""


class BSTreeNode(object):
    def __init__(self, value, leftNode = None, rightNode = None):
        self.m_nValue = value
        self.m_pLeft  = leftNode
        self.m_pRight = rightNode


    def __cmp__(self, other):
        if self.m_nValue == other.m_nValue:
            return 0
        elif self.m_nValue < other.m_nValue:
            return -1
        else:
            return 1


    def __lt__(self, other):
        if self.m_nValue < other.m_nValue:
            return True
        else:
            return False


    def __gt__(self, other):
        if self.m_nValue > other.m_nValue:
            return True
        else:
            return False
         
    def __eq__(self, other):
        if self.m_nValue == other.m_nValue:
            return True
        else:
            return False


    def __le__(self, other):
        if self.m_nValue <= other.m_nValue:
            return True
        else:
            return False


    def __ge__(self, other):
        if self.m_nValue >= other.m_nValue:
            return True
        else:
            return False




class BSTree(object):
    
    BSTREE_TYPE_TREE   = 1
    BSTREE_TYPE_DBLIST = 2
    
    def __init__(self, values = None):
        self.rootNode = None
        self.type     = self.BSTREE_TYPE_TREE
        self.values = values
        if values:
            self._sort()
        self.head = self.getHead()
        self.tail = self.getTail()


     
    def _sort(self):
        self.rootNode = BSTreeNode(values[0])
        for value in self.values[1:]:
            lastNode = self.rootNode
            newNode  = BSTreeNode(value)
            while True:
                if lastNode.m_pLeft is None and newNode <= lastNode:
                    lastNode.m_pLeft = newNode
                    break
                elif lastNode.m_pRight is None and newNode > lastNode:
                    lastNode.m_pRight = newNode
                    break
                else:
                    lastNode = lastNode.m_pLeft if newNode <= lastNode else lastNode.m_pRight


    def insert(self, value):
        newNode = BSTreeNode(value)
        if self.rootNode is None:
            self.rootNode = newNode
        else:
            lastNode = self.rootNode
            while True:
                if newNode <= lastNode:
                    
                    if lastNode.m_pLeft is None:
                        lastNode.m_pLeft = newNode
                        break
                    lastNode = lastNode.m_pLeft
                elif newNode > lastNode:
                    if lastNode.m_pRight is None:
                        lastNode.m_pRight = newNode
                        break
                    lastNode = lastNode.m_pRight


        
    def _dump(self, node):
        if node:
            self._dump(node.m_pLeft)
            print node.m_nValue
            self._dump(node.m_pRight)


    def dump(self):
        if self.type == self.BSTREE_TYPE_TREE:
            self._dump(self.rootNode)
        elif self.type == self.BSTREE_TYPE_DBLIST:
            self._dumpDoubleList()


    def _dumpDoubleList(self):
        print "Head -> Tail"
        curNode = self.head
        while curNode:
            print curNode.m_nValue
            curNode = curNode.m_pRight
        
        print "Tail -> Head"
        curNode = self.tail
        while curNode:
            print curNode.m_nValue
            curNode = curNode.m_pLeft


    def getHead(self):
        node = None
        if self.rootNode:
            node = self.rootNode
            while node.m_pLeft:
                node = node.m_pLeft
        return node
        


    def getTail(self):
        node = None
        if self.rootNode:
            node = self.rootNode
            while node.m_pRight:
                node = node.m_pRight
        return node
    
    def _convertToDoubleList(self, node, flag = False):
        # 递归结束
        if node is None:
            return None
        
        # 获得左右子树
        leftNode  = self._convertToDoubleList(node.m_pLeft, False)
        rightNode = self._convertToDoubleList(node.m_pRight, True)
        if leftNode is not None:
            leftNode.m_pRight = node
        node.m_pLeft = leftNode
        if rightNode is not None:
            rightNode.m_pLeft = node
        node.m_pRight = rightNode
        
        # 获得最小的节点
        if flag:
            while node.m_pLeft:
                node = node.m_pLeft
        # 获得最大的节点
        else:
            while node.m_pRight:
                node = node.m_pRight
                
        return node
    
    def convertToDoubleList(self, flag = False):
        """ 
        分析：可以采用递归的思想，先将左子树转成双向列表，再将右子树转成双向列表，
        最后将这两个双向列表及根结点组首尾相接，组合成一个双向列表。
        
        当我们到达某一结点准备调整以该结点为根结点的子树时，
        先调整其左子树将左子树转换成一个排好序的左子链表，
        再调整其右子树转换右子链表。
        最近链接左子链表的最右结点（左子树的最大结点）、当前结点和右子链表的最左结点（右子树的最小结点）。
        从树的根结点开始递归调整所有结点。
        """
        self.type = self.BSTREE_TYPE_DBLIST
        return self._convertToDoubleList(self.rootNode, flag)
    
    def _convertToDoubleList2(self, node):
        if node is None:
            return


        global lastNodeInList


        if node.m_pLeft:
            self._convertToDoubleList2(node.m_pLeft)
            
        node.m_pLeft = lastNodeInList
        if lastNodeInList:
            lastNodeInList.m_pRight = node
        lastNodeInList = node
        
        if node.m_pRight:
            self._convertToDoubleList2(node.m_pRight)
        
    def convertToDoubleList2(self):
        """
        二叉查找树的中序遍历结果是升序排列的，与题目要求相符。
        因此，考虑用中序遍历来给出结果。
        
        我们可以中序遍历整棵树。按照这个方式遍历树，比较小的结点先访问。
        如果我们每访问一个结点，假设之前访问过的结点已经调整成一个排序双向链表，
        我们再把调整当前结点的指针将其链接到链表的末尾。
        当所有结点都访问过之后，整棵树也就转换成一个排序双向链表了。
        """
        self.type = self.BSTREE_TYPE_DBLIST
        self._convertToDoubleList2(self.rootNode)
        
    


if __name__ == '__main__':


    values = [10, 6, 14, 4, 8, 12, 16]
    tree = BSTree(values)
    print "BSTreeNode test"
    tree.dump()
    tree.convertToDoubleList()
    print "BSTreeNode DoubleList test"
    tree.dump()
    
    print "BSTreeNode DoubleList convertToDoubleList test"    
    tree = BSTree(values)
    tail = tree.convertToDoubleList(False)


    print "Tail -> Head"
    while tail:
        print tail.m_nValue
        tail = tail.m_pLeft 


    tree = BSTree(values)
    head = tree.convertToDoubleList(True)
    print "Head -> Tail"
    while head:
        print head.m_nValue
        head = head.m_pRight


    print "BSTreeNode DoubleList convertToDoubleList2 test"
    tree = BSTree(values)
    lastNodeInList = None
    tree.convertToDoubleList2()
    tail = lastNodeInList
    print "Tail -> Head"
    while tail:
        print tail.m_nValue
        tail = tail.m_pLeft