将搜索二叉树转换成双向链表

将搜索二叉树转换成双向链表

题目描述

对二叉树的节点来说，有本身的值域，有指向左孩子节点和右孩子节点的两个指针；对双向链表的节点来说，有本身的值域，有指向上一个节点和下一个节点的指针。在结构上，两种结构有相似性，现在有一棵搜索二叉树，请将其转换成一个有序的双向链表。

输入描述：

第一行一个数字 n 表示二叉树的总结点数。
以下 n 行每行三个整数 fa lch rch，表示节点 fa 的左儿子节点为 lch，右儿子节点为 rch。(若 lch 为 0 则表示 fa 没有左儿子，rch同理)

第一行的 fa 为根节点。

ps:节点的标号就是节点的值。

输出描述：

在给定的函数中返回双向链表的头指针。

示例1

输入

9
6 4 7
4 2 5
2 1 3
5 0 0
1 0 0
3 0 0
7 0 9
9 8 0
8 0 0

输出

1 2 3 4 5 6 7 8 9

备注：

$1\le n\le 10^6$

$1\le fa,lch,rch\le 10^6$

---

题解：

很容易知道双向链表是二叉树的中序遍历结果。

法一

使用队列等容器收集中序遍历结果，然后依次弹出所有元素，重新连接即可。时间复杂度为$O(N)$，额外的空间复杂度为$O(N)$。

法一也可以按照中序遍历的过程直接连接节点形成双向链表，这样的话，由于不是在二叉树上进行调整，额外的空间复杂度同样为$O(N)$。

法二

直接在二叉树上调整，额外的空间复杂度为$O(H)$，H 为二叉树的高度。我们在纸上画一画可以知道：左子树的最右节点是根节点的前驱节点，右子树的最左节点是根节点的后继节点。根据这个特性，递归进行以下操作：

• 首先转换左子树，形成双向链表，将双向链表尾节点（左子树最右节点，根节点的前驱节点）连接到根节点；
• 然后转换右子树，形成双向链表，将双向链表首节点（右子树最左节点，根节点的后继节点）连接到根节点。

这样递归进行拼接，即可形成完整的双向链表。

优化

二叉树的的神级遍历：Morris遍历。据说可以做到 $O(1)$ 的额外空间复杂度。留坑待填。。。

法二代码：

# include <bits/stdc++.h>
using namespace std;

struct BST{
    int val;
    struct BST * lch, * rch;
};

BST * input_BST()
{
    int n, fa, lch, rch;
    scanf("%d", &n);
    BST * root, * new_node;
    map<int, BST *> mp;
    for (int i = 1; i <= n; ++i) {
        scanf("%d %d %d", &fa, &lch, &rch);
        if (mp.find(fa) == mp.end()) {
            new_node = (BST *)malloc(sizeof(BST));
            mp[fa] = new_node;
            new_node->val = fa;
            if (i == 1) root = new_node;
        }
        if (lch && mp.find(lch) == mp.end()) {
            new_node = (BST *)malloc(sizeof(BST));
            mp[lch] = new_node;
            new_node->val = lch; new_node->lch = new_node->rch = NULL;
        }
        if (rch && mp.find(rch) == mp.end()) {
            new_node = (BST *)malloc(sizeof(BST));
            mp[rch] = new_node;
            new_node->val = rch; new_node->lch = new_node->rch = NULL;
        }
        mp[fa]->lch = (lch ? mp[lch] : NULL);
        mp[fa]->rch = (rch ? mp[rch] : NULL);
    }
    return root;
}

BST * convertTree(BST * root)
{
    //在下面完成代码
    if (!root || (!root->lch && !root->rch)) return root;
    BST *left = convertTree(root->lch);
    if (left) {
        while (left->rch) left = left->rch;
        left->rch = root;
        root->lch = left;
    }
    BST *right = convertTree(root->rch);
    if (right) {
        while (right->lch) right = right->lch;
        root->rch = right;
        right->lch = root;
    }
    return root;
}

BST * convert(BST * root) {
    root = convertTree(root);
    while (root && root->lch) root = root->lch;
    return root;
}

void print_double_list(BST *root)
{
    while (root != NULL) {
        printf("%d ", root->val);
        root = root->rch;
    }
    puts("");
}

int main ()
{
    BST * root = input_BST();
    root = convert(root);
    print_double_list(root);
    return 0;
}