剑指offer系列26之二叉搜索树与双向链表

要求

• 时间限制：1秒
• 空间限制：32768K
• 热度指数：204813

题目描述

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

思路

思路一：非递归法

非递归法主要利用了二叉树的中序遍历的非递归方法。

python实现

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Convert(self, pRootOfTree):
        # write code here
        if pRootOfTree == None:
            return None
        stack = []
        p = pRootOfTree
        pre = None
        first_flag = 1
        while p or len(stack)>0:
            while p:
                stack.append(p)
                p = p.left
            p = stack[-1]
            stack.pop()
            if first_flag:
                pRootOfTree = p
                pre = pRootOfTree
                first_flag = 0
            else:
                pre.right = p
                p.left = pre
                pre = p
            p = p.right
        return pRootOfTree

• 运行时间：33ms
• 占用内存：5856k

C++实现

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if (pRootOfTree==NULL)
            return pRootOfTree;
        TreeNode* p = pRootOfTree;
        TreeNode* pre = NULL;
        vector<TreeNode*> stack;
        bool first = true;
        while (p!=NULL || !stack.empty()){
            while (p){
                stack.push_back(p);
                p = p->left;
            }
            p = stack.back();
            stack.pop_back();
            if (first){
                pRootOfTree = p;
                pre = pRootOfTree;
                first = false;
            }
            else{
                pre->right = p;
                p->left = pre;
                pre = pre->right;
            }
            p = p->right;
        }
        return pRootOfTree;
    }
};

• 运行时间：3ms
• 占用内存：472k

思路二：递归法

python实现

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    head = None
    p = None
    
    def Convert(self, pRootOfTree):
        # write code here
        if not pRootOfTree:
            return None
        self.subConvert(pRootOfTree)
        return self.head
    
    def subConvert(self, pRootOfTree):
        if pRootOfTree == None:
            return
        self.subConvert(pRootOfTree.left)
        if not self.head:
            self.head = pRootOfTree
            self.p = self.head
        else:
            self.p.right = pRootOfTree
            pRootOfTree.left = self.p
            self.p = pRootOfTree
        self.subConvert(pRootOfTree.right)
        

• 运行时间：28ms
• 占用内存：5760k

C++实现

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    TreeNode* p = NULL; TreeNode* head = NULL;
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if (!pRootOfTree) return pRootOfTree;
        subConvert(pRootOfTree);
        return head;
    }
    void subConvert(TreeNode* pRootOfTree){
        if (!pRootOfTree) return;
        subConvert(pRootOfTree->left);
        if (head==NULL){
            p = pRootOfTree;
            head = p;
        }
        else {
            p->right = pRootOfTree;
            pRootOfTree->left = p;
            p = pRootOfTree;
        }
        subConvert(pRootOfTree->right);
    }
};

• 运行时间：3ms
• 占用内存：484k

下面这种方法创建了新节点，不满足条件。

C++实现

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/

class Solution {
private:
    TreeNode head = TreeNode(0);
    TreeNode *pTail = &head;
public:
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if(!pRootOfTree)
            return NULL;
        //开始中序遍历
        Convert(pRootOfTree->left);

        pTail->right = pRootOfTree;
        pRootOfTree->left = pTail;
        pTail = pRootOfTree;

        Convert(pRootOfTree->right);
        //将第二个节点的左指针指向空
        if(head.right)
            head.right->left = NULL;
        return head.right;
    }
};

• 运行时间：3ms

• 占用内存：588k

C++实现

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<TreeNode*> v;
    void postTra(TreeNode* root){
        if (root==NULL)
            return;
        postTra(root->left);
        v.push_back(root);
        postTra(root->right);
    }
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if (pRootOfTree==NULL)
            return pRootOfTree;
        else if (pRootOfTree->left==NULL && pRootOfTree->right==NULL)
            return pRootOfTree;
        postTra(pRootOfTree);
        for (int i=0; i<v.size(); i++){
            if (i==0)
                v[i]->left = NULL;
            else
                v[i]->left = v[i-1];
            if (i==v.size()-1)
                v[i]->right = NULL;
            else 
                v[i]->right = v[i+1];
        }
        return v[0];
    }
};

• 运行时间：3ms

• 占用内存：576k