c++ 编程珠玑

经典的将二叉搜索树转换成双向链表, 不许创建新节点. 下面的递归解法很经典, 好好揣摩.

递归解法

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
#include<iostream>
#include<stack>
using namespace std;

class Solution {
public:
    TreeNode* res;
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if(pRootOfTree == nullptr) return nullptr;
        TreeNode* pre = nullptr;
        convertHelper(pRootOfTree, pre);
        return res;
    }
    
    // *& 很重要, 必须使用引用, 否则当前 pre 并没有更新到最新位置
    void convertHelper(TreeNode* cur, TreeNode*& pre)  
    {
        if(cur == nullptr) return;
         
        convertHelper(cur->left, pre);
         
        cur->left = pre;
        if(pre) {
            pre->right = cur;  // 用于处理链表的起始位置
        } else {
            res = cur;
        }
        pre = cur;
        convertHelper(cur->right, pre);
    }
};

非递归解法

#include<iostream>
#include<stack>
using namespace std;

class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree) {
        if (!pRootOfTree) {
            return nullptr;
        }
        TreeNode DummyHead(-1);
        TreeNode *dp = &DummyHead;
        TreeNode *p = pRootOfTree;
        stack<TreeNode*> st;
        while (p || !st.empty()) {
            if (p) {
                st.push(p);
                p = p->left;
            } else {
                p = st.top();
                st.pop();
                dp->right = p;
                p->left = dp;
                dp = p;
                p = p->right;
            }
        }
        DummyHead.right->left = nullptr;
        return DummyHead.right;
    }
};