LintCode 85 (LeetCode 701): Insert Node in a Binary Search Tree

原创已于 2022-11-08 17:10:12 修改 · 189 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode

于 2019-04-29 15:24:50 首次发布

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文详细介绍了如何在二叉搜索树中插入新节点，并保持树的性质不变。提供了递归与非递归两种实现方法，同时强调了无重复值的假设条件。

Insert Node in a Binary Search Tree
中文English
Given a binary search tree and a new tree node, insert the node into the tree. You should keep the tree still be a valid binary search tree.

Example
Example 1:
Input: tree = {}, node = 1
Output: 1

Explanation:
Insert node 1 into the empty tree, so there is only one node on the tree.

Example 2:
Input: tree = {2,1,4,3}, node = 6
Output: {2,1,4,3,6}

Explanation: 
Like this:



  2             2
 / \           / \
1   4   -->   1   4
   /             / \ 
  3             3   6

Challenge
Can you do it without recursion?

Notice
You can assume there is no duplicate values in this tree + node.

代码如下：

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */


class Solution {
public:
    /*
     * @param root: The root of the binary search tree.
     * @param node: insert this node into the binary search tree
     * @return: The root of the new binary search tree.
     */
    TreeNode * insertNode(TreeNode * root, TreeNode * node) {
       if (!root) return node;
       if (node->val < root->val) {
           root->left = insertNode(root->left, node);
       } else {
           root->right = insertNode(root->right, node);
       }
       return root;
    }
};

二刷：

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */


class Solution {
public:
    /*
     * @param root: The root of the binary search tree.
     * @param node: insert this node into the binary search tree
     * @return: The root of the new binary search tree.
     */
    TreeNode * insertNode(TreeNode * root, TreeNode * node) {
        if (!root) return node;
        if (!node) return root;
        
        if (node->val < root->val) {
            root->left = insertNode(root->left, node);
            return root;
        }

        if (node->val > root->val) {
            root->right = insertNode(root->right, node);
            return root;
        }
        
        return root;
    }
};

三刷：非递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (!root) {
            return new TreeNode(val);
        }
        TreeNode *origRoot = root;
        TreeNode *pre = nullptr;
        while (root) {
            pre = root;
            if (val < root->val) {
                root = root->left; //it is guaranteed that val != root->val
            } else {
                root = root->right;
            }
        }
        if (val < pre->val) pre->left = new TreeNode(val);
        else pre->right = new TreeNode(val);
        return origRoot;
    }
};

四刷：非递归

class Solution {
public:
    /*
     * @param root: The root of the binary search tree.
     * @param node: insert this node into the binary search tree
     * @return: The root of the new binary search tree.
     */
    TreeNode * insertNode(TreeNode * root, TreeNode * node) {
       if (!root) return node;
       TreeNode *origRoot = root;
       while (root) {
           if (node->val > root->val) {
               if (root->right) {
                   root = root->right;
               } else {
                   root->right = node;
                   break;
               }
           } else {
               if (root->left) {
                   root = root->left;
               } else {
                   root->left = node;
                   break;
               }
           }
       }
       return origRoot;
    }
};