二叉搜索树与双向链表，Python实现

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Stack:
    def __init__(self):
        self.depth = -1
        self.elems = []
    def is_empty(self):
        return self.depth == -1
    def push(self, elem):
        self.elems.append(elem)
        self.depth += 1
    def pop(self):
        if not self.is_empty():
            self.depth -= 1
            return self.elems.pop()
        return None

def get_tree(tree_node_num):
    root = TreeNode(1)
    st = Stack()
    st.push(root)
    i = 2
    while True:
        if i < tree_node_num+2:
            tree_node = st.pop()
            tree_node.left = TreeNode(i)
            st.push(tree_node.left)
            i += 1
            if i > tree_node_num+2:
                break
            tree_node.right = TreeNode(i)
            st.push(tree_node.right)
            i += 1
        else:
            break
    while not st.is_empty():
        st.pop()
    return root


def travel(root):
    if root == None:
        return None
    print(root.val)
    travel(root.left)
    travel(root.right)


class Solution:
    def __init__(self):
        self.listHead = None
        self.listTail = None

    def convert_node(self, root):
        if root == None:
            return None
        self.convert_node(root.left)
        if self.listHead == None:
            self.listHead = root
            self.listTail = root
        else:
            self.listTail.right = root
            root.left = self.listTail
            self.listTail = root
        self.convert_node(root.right)
        return self.listHead

    def print_list(self, head):
        p = head
        while p.right:
            print(p.val, end=" ")
            p = p.right
        print(p.val)
        while p:
            print(p.val, end=" ")
            p = p.left
            
            

    
if __name__ == "__main__":
    root = get_tree(10)
    so = Solution()
    root = so.convert_node(root)
    so.print_list(root)