Question

我试图理解和实现基本定理，以发现递归关系的时间复杂性。

但是，我无法理解如何使用该算法来计算算法的时间复杂度。

考虑使用这种算法来查找二叉树的直径

class Node 
{
    int data; 
    Node left, right; 

    public Node(int item) 
    { 
        data = item; 
        left = right = null; 
    }
}





/* Class to print the Diameter */

    class BinaryTree 

{ 
    Node root; 

    /* Method to calculate the diameter and return it to main */
    int diameter(Node root) 
    { 
        /* base case if tree is empty */
        if (root == null) 
            return 0; 

        /* get the height of left and right sub trees */
        int lheight = height(root.left); 
        int rheight = height(root.right); 

        /* get the diameter of left and right subtrees */
        int ldiameter = diameter(root.left); 
        int rdiameter = diameter(root.right); 

        /* Return max of following three 
          1) Diameter of left subtree 
         2) Diameter of right subtree 
         3) Height of left subtree + height of right subtree + 1 */
        return Math.max(lheight + rheight + 1, 
                        Math.max(ldiameter, rdiameter)); 

    } 

    /* A wrapper over diameter(Node root) */
    int diameter() 
    { 
        return diameter(root); 
    } 

    /*The function Compute the "height" of a tree. Height is the 
      number f nodes along the longest path from the root node 
      down to the farthest leaf node.*/
    static int height(Node node) 
    { 
        /* base case tree is empty */
        if (node == null) 
            return 0; 

        /* If tree is not empty then height = 1 + max of left 
           height and right heights */
        return (1 + Math.max(height(node.left), height(node.right))); 
    } 

    public static void main(String args[]) 
    { 
        /* creating a binary tree and entering the nodes */
        BinaryTree tree = new BinaryTree(); 
        tree.root = new Node(1); 
        tree.root.left = new Node(2); 
        tree.root.right = new Node(3); 
        tree.root.left.left = new Node(4); 
        tree.root.left.right = new Node(5); 

        System.out.println("The diameter of the given binary tree is: "
                           + tree.diameter()); 
    } 
}

我知道上述算法的时间复杂度为O（n ^ 2）只看它。由于每个节点都需要大量时间才能进行一次递归。

如何使用Master方法找到该算法的时间复杂度？

在寻找递归函数的时间复杂度时，我完全是一个新手。而且我认为Master Theorem是一种计算递归函数时间复杂度的方法。

如何通过使用主方法或任何其他方法来找到递归算法的时间复杂度？

如果有人可以教我如何找到递归函数的时间复杂性，那将是一个很大的帮助。

谢谢！

Answer 1

如果我们假设二叉树是平衡的，则总时间复杂度为T(n)和T(n) = 2T(n/2) + 2T(n/2) + 1。第一个2T(n/2)代表直径（左右），第二个2T(n/2)代表高度（左右高度）。因此，T(n) = 4T(n/2) + 1 = O(n^2)（master theorem的第一种情况）。

掌握定理，找出递归关系的时间复杂度

1 个答案: