📜  在 O(1) 空间中打印二叉树的 K 个中序后继

📅  最后修改于: 2021-09-04 13:02:36             🧑  作者: Mango

给定一个二叉树和两个数字PK ,任务是在恒定空间中从二叉树打印给定数字PK 中序后继。
例子:

方法:
为了解决这个问题,我们使用二叉树的莫里斯中序遍历来避免使用任何额外的空间。在生成中序序列时搜索节点“P”。找到后,打印出现在中序序列中的下K 个节点。
下面是上述方法的实现:

C++
1
        /   \
      12      11
     /       /   \
    3       4     13
            \      /
            15    9


Java
5
                /   \
              21    77
             /  \      \
            61   16    36
                  \     /
                   10  3
                  /
                 23


Python3
// C++ implementation to print K Inorder
// Successor of the Binary Tree
// without using extra space
 
#include 
using namespace std;
 
/* A binary tree Node has data,
  a pointer to left child
  and a pointer to right child */
struct tNode {
    int data;
    struct tNode* left;
    struct tNode* right;
};
 
/* Function to traverse the
  binary tree without recursion and
  without stack */
void MorrisTraversal(struct tNode* root,
                     int p, int k)
{
    struct tNode *current, *pre;
 
    if (root == NULL)
        return;
 
    bool flag = false;
 
    current = root;
 
    while (current != NULL) {
 
        // Check if the left child exists
        if (current->left == NULL) {
 
            if (flag == true) {
                cout << current->data
                     << " ";
                k--;
            }
            if (current->data == p)
                flag = true;
 
            // Check if K is 0
            if (k == 0)
                flag = false;
 
            // Move current to its right
            current = current->right;
        }
        else {
 
            // Find the inorder predecessor
            // of current
            pre = current->left;
            while (pre->right != NULL
                   && pre->right != current)
                pre = pre->right;
 
            /* Make current as the right
               child of its inorder
                  predecessor */
            if (pre->right == NULL) {
                pre->right = current;
                current = current->left;
            }
 
            /* Revert the changes made in the
               'if' part to restore the original
               tree i.e., fix the right child
                 of predecessor */
            else {
                pre->right = NULL;
                if (flag == true) {
                    cout << current->data
                         << " ";
                    k--;
                }
                if (current->data == p)
                    flag = true;
 
                if (k == 0)
                    flag = false;
 
                current = current->right;
            }
        }
    }
}
 
/* Function that allocates
   a new Node with the
   given data and NULL left
   and right pointers. */
struct tNode* newtNode(int data)
{
    struct tNode* node = new tNode;
    node->data = data;
    node->left = NULL;
    node->right = NULL;
 
    return (node);
}
 
/* Driver code*/
int main()
{
 
    struct tNode* root = newtNode(1);
 
    root->left = newtNode(12);
    root->right = newtNode(11);
    root->left->left = newtNode(3);
    root->right->left = newtNode(4);
    root->right->right = newtNode(13);
 
    root->right->left->right = newtNode(15);
    root->right->right->left = newtNode(9);
 
    int p = 12;
    int k = 4;
 
    MorrisTraversal(root, p, k);
 
    return 0;
}


C#
// Java implementation to print K Inorder
// Successor of the Binary Tree
// without using extra space
 
// A binary tree tNode has data,
// a pointer to left child
// and a pointer to right child
class tNode
{
    int data;
    tNode left, right;
 
    tNode(int item)
    {
        data = item;
        left = right = null;
    }
}
 
class BinaryTree{
     
tNode root;
 
// Function to traverse a binary tree
// without recursion and without stack
void MorrisTraversal(tNode root, int p, int k)
{
    tNode current, pre;
 
    if (root == null)
        return;
         
    boolean flag = false;
    current = root;
     
    while (current != null)
    {
        if (current.left == null)
        {
            if (flag == true)
            {
                System.out.print(current.data + " ");
                k--;
            }
            if (current.data == p)
            {
                flag = true;
            }
            if (k == 0)
            {
                flag = false;
            }
            current = current.right;
        }
        else
        {
             
            // Find the inorder predecessor
            // of current
            pre = current.left;
            while (pre.right != null &&
                   pre.right != current)
                pre = pre.right;
 
            // Make current as right child of
            // its inorder predecessor
            if (pre.right == null)
            {
                pre.right = current;
                current = current.left;
            }
 
            // Revert the changes made in the
            // 'if' part to restore the original
            // tree i.e., fix the right child of
            // predecessor
            else
            {
                pre.right = null;
                if (flag == true)
                {
                    System.out.print(current.data + " ");
                    k--;
                }
                if (current.data == p)
                {
                    flag = true;
                }
                if (k == 0)
                {
                    flag = false;
                }
                current = current.right;
            }
        }
    }
}
 
// Driver code
public static void main(String args[])
{
    BinaryTree tree = new BinaryTree();
     
    tree.root = new tNode(1);
    tree.root.left = new tNode(12);
    tree.root.right = new tNode(11);
    tree.root.left.left = new tNode(3);
    tree.root.right.left = new tNode(4);
    tree.root.right.right = new tNode(13);
     
    tree.root.right.left.right = new tNode(15);
    tree.root.right.right.left = new tNode(9);
     
    int p = 12;
    int k = 4;
     
    tree.MorrisTraversal(tree.root, p, k);
}
}
 
// This code is contributed by MOHAMMAD MUDASSIR


输出:
# Python3 implementation to print K Inorder
# Successor of the Binary Tree
# without using extra space
  
''' A binary tree Node has data,
  a pointer to left child
  and a pointer to right child '''
class tNode:
     
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
  
''' Function to traverse the
  binary tree without recursion and
  without stack '''
def MorrisTraversal(root, p, k):
 
    current = None
    pre = None
  
    if (root == None):
        return;
  
    flag = False;
  
    current = root;
  
    while (current != None):
  
        # Check if the left child exists
        if (current.left == None):
  
            if (flag == True):
                print(current.data, end = ' ')
                 
                k -= 1
             
            if (current.data == p):
                flag = True;
  
            # Check if K is 0
            if (k == 0):
                flag = False;
  
            # Move current to its right
            current = current.right;
         
        else:
  
            # Find the inorder predecessor
            # of current
            pre = current.left
             
            while (pre.right != None and pre.right != current):
                pre = pre.right;
  
            # Make current as the right
            #child of its inorder predecessor
            if(pre.right == None):
                pre.right = current;
                current = current.left;
                 
            # Revert the changes made in the
            # 'if' part to restore the original
            # tree i.e., fix the right child
            # of predecessor
            else:
                pre.right = None;
                if (flag == True):
                    print(current.data, end = ' ')
                     
                    k -= 1
                 
                if (current.data == p):
                    flag = True;
  
                if (k == 0):
                    flag = False;
  
                current = current.right;
  
''' Function that allocates
   a new Node with the
   given data and None left
   and right pointers. '''
def newtNode(data):
 
    node = tNode(data);
    return (node);
 
# Driver code
if __name__=='__main__':
  
    root = newtNode(1);
  
    root.left = newtNode(12);
    root.right = newtNode(11);
    root.left.left = newtNode(3);
    root.right.left = newtNode(4);
    root.right.right = newtNode(13);
  
    root.right.left.right = newtNode(15);
    root.right.right.left = newtNode(9);
  
    p = 12;
    k = 4;
  
    MorrisTraversal(root, p, k);
  
# This code is contributed by rutvik_56

如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live