[leetcode] 树(Ⅲ)

All questions are simple level.

Minimum Distance Between BST Nodes

Question[783]: Given a Binary Search Tree (BST) with the root node root, return the minimum difference between the values of any two different nodes in the tree.

Example

Input: root = [4,2,6,1,3,null,null]
Output: 1
Explanation: Note that root is a TreeNode object, not an array. The given tree [4,2,6,1,3,null,null] is represented by the following diagram:

          4
        /   \
      2      6
     / \    
    1   3  

while the minimum difference in this tree is 1, it occurs between node 1 and node 2, also between node 3 and node 2.

Solution

Inorder traversal, only once traversal.

class Solution
{
public:
    int minDiffInBST(TreeNode *root)
    {
        return inorder2(root);
    }

    int inorder2(TreeNode *root)
    {
        bool first = true;
        int diff = 0x7ffffff;
        int pre = -1;
        auto p = root;
        stack s;
        while (p != nullptr || !s.empty())
        {
            if (p != nullptr)
            {
                s.push(p);
                p = p->left;
            }
            else
            {
                p = s.top(), s.pop();
                if (first)
                    pre = p->val, first = false;
                else
                    diff = min(diff, abs(p->val - pre)), pre = p->val;
                p = p->right;
            }
        }
        return diff;
    }

    int inorder(TreeNode *root)
    {
        vector v;
        auto p = root;
        stack s;
        while (p != nullptr || !s.empty())
        {
            if (p != nullptr)
            {
                s.push(p);
                p = p->left;
            }
            else
            {
                p = s.top(), s.pop();
                v.push_back(p->val);
                p = p->right;
            }
        }
        int diff = abs(v[1] - v[0]);
        for (int i = 2; i < (int)v.size(); i++)
            diff = min(diff, abs(v[i] - v[i - 1]));
        return diff;
    }
};

Leaf-Similar Trees

Question[872]: Consider all the leaves of a binary tree. From left to right order, the values of those leaves form a leaf value sequence. Two binary trees are considered leaf-similar if their leaf value sequence is the same. Return true if and only if the two given trees with head nodes root1 and root2 are leaf-similar.

Solution

Inorder traversal.

class Solution
{
public:
    bool leafSimilar(TreeNode *root1, TreeNode *root2)
    {
        return inorder(root1) == inorder(root2);
    }
    vector inorder(TreeNode *root)
    {
        vector v;
        auto p = root;
        stack s;
        while (!s.empty() || p != nullptr)
        {
            if (p != nullptr)
            {
                s.push(p);
                p = p->left;
            }
            else
            {
                p = s.top(), s.pop();
                if (p->left == nullptr && p->right == nullptr)
                    v.push_back(p->val);
                p = p->right;
            }
        }
        return v;
    }
};

Increasing Order Search Tree

Question[897]: Given a binary search tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only 1 right child.

Example

Input: [5,3,6,2,4,null,8,1,null,null,null,7,9]
       5
      / \
    3    6
   / \    \
  2   4    8
 /        / \ 
1        7   9
Output: [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
 1
  \
   2
    \
     3
      \
       4
        \
         5
          \
           6
            \
             7
              \
               8
                \
                 9  

Solution

TreeNode *increasingBST(TreeNode *root)
{
    return inorder(root);
}
TreeNode *inorder(TreeNode *oldRoot)
{
    TreeNode *newRoot = new TreeNode(-1);
    auto t = newRoot;
    auto p = oldRoot;
    stack s;
    while (p != nullptr || !s.empty())
    {
        if (p != nullptr)
            s.push(p), p = p->left;
        else
        {
            p = s.top(), s.pop();
            t->right = new TreeNode(p->val);
            t = t->right;
            p = p->right;
        }
    }
    return newRoot->right;
}

Range Sum of BST

Question[938]: Given the root node of a binary search tree, return the sum of values of all nodes with value between L and R (inclusive). The binary search tree is guaranteed to have unique values.

Example

Input: root = [10,5,15,3,7,null,18], L = 7, R = 15
Output: 32

Solution

Three solutions.

  • Inorder traversal
int inorder(TreeNode *root, int l, int r)
{
    int sum = 0;
    auto p = root;
    stack s;
    while (p != nullptr || !s.empty())
    {
        if (p)
            s.push(p), p = p->left;
        else
        {
            p = s.top(), s.pop();
            if (l <= p->val && p->val <= r)
                sum += p->val;
            else if (p->val > r)
                break;
            p = p->right;
        }
    }
    return sum;
}
  • Search by recursion
int sum = 0;
void helper(TreeNode *root, int l, int r)
{
    if (root == nullptr)    return;
    if (root->val < l)      helper(root->right, l, r);
    else if (root->val > r) helper(root->left, l, r);
    else
    {
        sum += root->val;
        helper(root->left, l, r);
        helper(root->right, l, r);
    }
}
  • Search by iteration(stack)
int search(TreeNode *root, int l, int r)
{
    int result = 0;
    auto p = root;
    stack s;
    s.push(p);
    while (!s.empty())
    {
        p = s.top(), s.pop();
        if (p == nullptr)
            continue;
        if (l <= p->val && p->val <= r)
        {
            result += p->val;
            s.push(p->right);
            s.push(p->left);
        }
        else if (p->val < l)
            s.push(p->right);
        else if (p->val > r)
            s.push(p->left);
    }
    return result;
}

Cousins in Binary Tree

Question[993]: In a binary tree, the root node is at depth 0, and children of each depth k node are at depth k+1. Two nodes of a binary tree are cousins if they have the same depth, but have different parents. We are given the root of a binary tree with unique values, and the values x and y of two different nodes in the tree. Return true if and only if the nodes corresponding to the values x and y are cousins.

Solution

Level order traversal.

class Solution
{
public:
    bool isCousins(TreeNode *root, int x, int y)
    {
        if (root == nullptr)
            return false;
        queue q;
        TreeNode *xparent = nullptr, *yparent = nullptr;
        auto p = root;
        q.emplace(p);
        while (!q.empty())
        {
            queue nextlevel;
            while (!q.empty())
            {
                p = q.front(), q.pop();
                if (p->left)
                {
                    nextlevel.emplace(p->left);
                    if (x == p->left->val)
                        xparent = p;
                    if (y == p->left->val)
                        yparent = p;
                }
                if (p->right)
                {
                    nextlevel.emplace(p->right);
                    if (x == p->right->val)
                        xparent = p;
                    if (y == p->right->val)
                        yparent = p;
                }
            }
            q = nextlevel;
            // not found yet
            if (xparent == nullptr && yparent == nullptr)
                continue;
            // not same level
            if ((xparent == nullptr) ^ (yparent == nullptr))
                return false;
            // found at same level
            return xparent != yparent;
        }
        // can not be here
        return false;
    }
};

Sum of Root To Leaf Binary Numbers

Question[1022]: Given a binary tree, each node has value 0 or 1. Each root-to-leaf path represents a binary number starting with the most significant bit. For example, if the path is 0 -> 1 -> 1 -> 0 -> 1, then this could represent 01101 in binary, which is 13. For all leaves in the tree, consider the numbers represented by the path from the root to that leaf. Return the sum of these numbers.

Example

Input: [1,0,1,0,1,0,1]
Output: 22
Explanation: (100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22

Solution

Bit operation and back-track method(preorder traversal actually). Use val = (val << 1) | p->val to record a path.

class Solution
{
public:
    int sum = 0;
    int sumRootToLeaf(TreeNode *root)
    {
        preorder(0, root);
        return sum;
    }
    void preorder(int val, TreeNode *p)
    {
        if (p == nullptr)
            return;
        val = (val << 1) | p->val;
        if (p->left == nullptr && p->right == nullptr)
            sum += val;
        preorder(val, p->left);
        preorder(val, p->right);
    }
};

Interview Questions

BiNode LCCI

Question[17.12]: The data structure TreeNode is used for binary tree, but it can also used to represent a single linked list (where left is null, and right is the next node in the list). Implement a method to convert a binary search tree (implemented with TreeNode) into a single linked list. The values should be kept in order and the operation should be performed in place (that is, on the original data structure). Return the head node of the linked list after converting.

Example

Input:  [4,2,5,1,3,null,6,0]
Output:  [0,null,1,null,2,null,3,null,4,null,5,null,6]

Solution

Inorder traversal.

TreeNode *convertBiNode(TreeNode *root)
{
    TreeNode *newRoot = new TreeNode(-1);
    auto t = newRoot;
    auto p = root;
    stack s;
    while (!s.empty() || p != nullptr)
    {
        if (p)
        {
            s.emplace(p);
            p = p->left;
        }
        else
        {
            p = s.top(), s.pop();
            t->right = p, t = t->right;
            p = p->right;
        }
    }
    t = newRoot;
    while (t)
        t->left = nullptr, t = t->right;
    return newRoot->right;
}

你可能感兴趣的:([leetcode] 树(Ⅲ))