📜  用括号表示从字符串构造二叉树 |设置 2

📅  最后修改于: 2022-05-13 01:57:07.184000             🧑  作者: Mango

用括号表示从字符串构造二叉树 |设置 2

给定一个由括号 { '(' and ')' } 和整数组成的字符串s ,任务是从它构造一个二叉树并打印它的前序遍历。

例子:

递归方法:参考上一篇文章递归解决问题。
时间复杂度: O(N 2 )
辅助空间: O(N)

方法:这个问题可以使用栈数据结构来解决。请按照以下步骤解决问题:

  • 将位置0处的字符更新为二叉树的 并初始化一个堆栈stk
  • 使用变量i[1, N-1]范围内迭代:  
    • 如果遇到'(' ,则将压入堆栈stk
    • 否则,如果遇到')' ,则将更新为堆栈的最顶层元素并弹出最顶层元素。
    • 否则,如果字符是数字,则分支到为空的部分(左或右)。
  • 上述步骤结束,返回二叉树的根节点

下面是上述方法的实现:

C++
// C++ program for the above approach
 
#include 
using namespace std;
 
// Build a tree node having left and
// right pointers set to null initially
struct Node {
    Node* left;
    Node* right;
    int data;
 
    // Constructor to set the data of
    // the newly created tree node
    Node(int element)
    {
        data = element;
        this->left = nullptr;
        this->right = nullptr;
    }
};
 
// Utility function to print
// preorder traversal of the tree
void preorder(Node* root)
{
    if (!root)
        return;
 
    cout << root->data << " ";
    preorder(root->left);
    preorder(root->right);
}
 
// Function to construct a
// tree using bracket notation
Node* constructTree(string s)
{
 
    // First character is the root of the tree
    Node* root = new Node(s[0] - '0');
 
    // Stack used to store the
    // previous root elements
    stack stk;
 
    // Iterate over remaining characters
    for (int i = 1; i < s.length(); i++) {
 
        // If current character is '('
        if (s[i] == '(') {
 
            // Push root into stack
            stk.push(root);
        }
 
        // If current character is ')'
        else if (s[i] == ')') {
 
            // Make root the top most
            // element in the stack
            root = stk.top();
 
            // Remove the top node
            stk.pop();
        }
 
        // If current character is a number
        else {
 
            // If left is null, then put the new
            // node to the left and move to the
            // left of the root
            if (root->left == nullptr) {
 
                Node* left = new Node(s[i] - '0');
                root->left = left;
                root = root->left;
            }
 
            // Otherwise, if right is null, then
            // put the new node to the right and
            // move to the right of the root
            else if (root->right == nullptr) {
 
                Node* right = new Node(s[i] - '0');
                root->right = right;
                root = root->right;
            }
        }
    }
 
    // Return the root
    return root;
}
 
// Driver code
int main()
{
    // Input
    string s = "4(2(3)(1))(6(5))";
 
    // Function calls
    Node* root = constructTree(s);
    preorder(root);
 
    return 0;
}


Java
// Java program for the above approach
import java.util.*;
public class Main
{
    // Class containing left and
    // right child of current
    // node and key value
    static class Node {
        
        public int data;
        public Node left, right;
        
        public Node(int element)
        {
            data = element;
            left = right = null;
        }
    }
     
    // Utility function to print
    // preorder traversal of the tree
    static void preorder(Node root)
    {
        if (root == null)
            return;
       
        System.out.print(root.data + " ");
        preorder(root.left);
        preorder(root.right);
    }
       
    // Function to construct a
    // tree using bracket notation
    static Node constructTree(String s)
    {
       
        // First character is the root of the tree
        Node root = new Node(s.charAt(0) - '0');
       
        // Stack used to store the
        // previous root elements
        Stack stk = new Stack();
       
        // Iterate over remaining characters
        for (int i = 1; i < s.length(); i++) {
       
            // If current character is '('
            if (s.charAt(i) == '(') {
       
                // Push root into stack
                stk.push(root);
            }
       
            // If current character is ')'
            else if (s.charAt(i) == ')') {
       
                // Make root the top most
                // element in the stack
                root = stk.peek();
       
                // Remove the top node
                stk.pop();
            }
       
            // If current character is a number
            else {
       
                // If left is null, then put the new
                // node to the left and move to the
                // left of the root
                if (root.left == null) {
       
                    Node left = new Node(s.charAt(i) - '0');
                    root.left = left;
                    root = root.left;
                }
       
                // Otherwise, if right is null, then
                // put the new node to the right and
                // move to the right of the root
                else if (root.right == null) {
       
                    Node right = new Node(s.charAt(i) - '0');
                    root.right = right;
                    root = root.right;
                }
            }
        }
       
        // Return the root
        return root;
    }
     
    public static void main(String[] args) {
        // Input
        String s = "4(2(3)(1))(6(5))";
       
        // Function calls
        Node root = constructTree(s);
        preorder(root);
    }
}
 
// This code is contributed by divyesh072019.


Python3
# Python program for the above approach
 
# Build a tree node having left and
# right pointers set to null initially
class Node:
    # Constructor to set the data of
    # the newly created tree node
    def __init__(self, element):
        self.data = element
        self.left = None
        self.right = None
 
# Utility function to print
# preorder traversal of the tree
def preorder(root):
    if (not root):
        return
 
    print(root.data, end = " ")
    preorder(root.left)
    preorder(root.right)
 
# Function to construct a
# tree using bracket notation
def constructTree(s):
 
    # First character is the root of the tree
    root = Node(ord(s[0]) - ord('0'))
 
    # Stack used to store the
    # previous root elements
    stk = []
 
    # Iterate over remaining characters
    for i in range(1,len(s)):
        # If current character is '('
        if (s[i] == '('):
 
            # Push root into stack
            stk.append(root)
 
        # If current character is ')'
        elif (s[i] == ')'):
 
            # Make root the top most
            # element in the stack
            root = stk[-1]
 
            # Remove the top node
            del stk[-1]
        # If current character is a number
        else:
 
            # If left is null, then put the new
            # node to the left and move to the
            # left of the root
            if (root.left == None):
 
                left = Node(ord(s[i]) - ord('0'))
                root.left = left
                root = root.left
 
            # Otherwise, if right is null, then
            # put the new node to the right and
            # move to the right of the root
            elif (root.right == None):
 
                right =  Node(ord(s[i]) - ord('0'))
                root.right = right
                root = root.right
 
    # Return the root
    return root
 
# Driver code
if __name__ == '__main__':
    # Input
    s = "4(2(3)(1))(6(5))"
 
    # Function calls
    root = constructTree(s)
    preorder(root)
 
# This code is contributed by mohit kumar 29.


C#
// C# program for the above approach
using System;
using System.Collections;
class GFG
{
     
    // Class containing left and
    // right child of current
    // node and key value
    class Node {
       
        public int data;
        public Node left, right;
       
        public Node(int element)
        {
            data = element;
            left = right = null;
        }
    }
     
    // Utility function to print
    // preorder traversal of the tree
    static void preorder(Node root)
    {
        if (root == null)
            return;
      
        Console.Write(root.data + " ");
        preorder(root.left);
        preorder(root.right);
    }
      
    // Function to construct a
    // tree using bracket notation
    static Node constructTree(string s)
    {
      
        // First character is the root of the tree
        Node root = new Node(s[0] - '0');
      
        // Stack used to store the
        // previous root elements
        Stack stk = new Stack();
      
        // Iterate over remaining characters
        for (int i = 1; i < s.Length; i++) {
      
            // If current character is '('
            if (s[i] == '(') {
      
                // Push root into stack
                stk.Push(root);
            }
      
            // If current character is ')'
            else if (s[i] == ')') {
      
                // Make root the top most
                // element in the stack
                root = (Node)(stk.Peek());
      
                // Remove the top node
                stk.Pop();
            }
      
            // If current character is a number
            else {
      
                // If left is null, then put the new
                // node to the left and move to the
                // left of the root
                if (root.left == null) {
      
                    Node left = new Node(s[i] - '0');
                    root.left = left;
                    root = root.left;
                }
      
                // Otherwise, if right is null, then
                // put the new node to the right and
                // move to the right of the root
                else if (root.right == null) {
      
                    Node right = new Node(s[i] - '0');
                    root.right = right;
                    root = root.right;
                }
            }
        }
      
        // Return the root
        return root;
    }
 
  // Driver code
  static void Main()
  {
     
    // Input
    string s = "4(2(3)(1))(6(5))";
  
    // Function calls
    Node root = constructTree(s);
    preorder(root);
  }
}
 
// This code is contributed by decode2207.


Javascript



输出:
4 2 3 1 6 5

时间复杂度: O(N)
辅助空间: O(N)