Algorithm 我的哈夫曼算法非常复杂

有人能用Bog O表示法告诉我这个哈夫曼代码的空间和时间复杂性，并稍加解释吗。非常感谢，谢谢。请务必单独提及每种方法的大O，这将非常好。谢谢

package HuffmanProject;

import java.util.*;

class MyHCode {
public static void main(String[] args) {
String test = "My name is Zaryab Ali";
int[] FreqArray = new int[256];

for (char c : test.toCharArray()) {
FreqArray[c]++;
        }
MyHTree tree = ImplementTree(FreqArray);

System.out.println("CHARACTER\tFREQUENCY\tBINARY EQUIVALEENT CODE");
PrintMyHCode(tree, new StringBuffer());
    }

public static MyHTree ImplementTree(int[] FreqArray) {
PriorityQueue<MyHTree> trees = new PriorityQueue<MyHTree>();

for (int i = 0; i < FreqArray.length; i++) {
if (FreqArray[i] > 0) {
trees.offer(new MyHLeaf(FreqArray[i], (char) i));
            }
        }
while (trees.size() > 1) {
MyHTree FChild = trees.poll();
MyHTree SChild = trees.poll();
trees.offer(new MyHNode(FChild, SChild));
        }
return trees.poll();
    }

public static void PrintMyHCode(MyHTree tree, StringBuffer prefix) {

if (tree instanceof MyHLeaf) {
MyHLeaf leaf = (MyHLeaf) tree;
System.out.println(leaf.CharValue + "\t\t" + leaf.frequency + "\t\t" + prefix);
} 
else if (tree instanceof MyHNode) {
            MyHNode node = (MyHNode) tree;

            prefix.append('0');
            PrintMyHCode(node.left, prefix);
            prefix.deleteCharAt(prefix.length() - 1);

            prefix.append('1');
            PrintMyHCode(node.right, prefix);
            prefix.deleteCharAt(prefix.length() - 1);
        }
    }


}
abstract class MyHTree implements Comparable<MyHTree> {
public int frequency;

public MyHTree(int f) {
        frequency = f;
    }

public int compareTo(MyHTree tree) {
        return frequency - tree.frequency;
    }
}

class MyHLeaf extends MyHTree {
public char CharValue;

public MyHLeaf(int f, char v) {
        super(f);
        CharValue = v;
    }
}

class MyHNode extends MyHTree {
public MyHTree left, right;

public MyHNode(MyHTree l, MyHTree r) {
        super(l.frequency + r.frequency);
        left = l;
        right = r;
    }
}

哈夫曼项目包；
导入java.util.*；
类MyHCode{
公共静态void main（字符串[]args）{
String test=“我的名字是Zaryab Ali”；
int[]FreqArray=新int[256]；
for（char c:test.toCharArray（））{
频率数组[c]++；
}
MyHTree-tree=ImplementTree（FreqArray）；
System.out.println（“字符\t频率\t二进制等效代码”）；
PrintMyHCode（树，新StringBuffer（））；
}
公共静态MyHTree实现树（int[]FreqArray）{
PriorityQueue树=新建PriorityQueue（）；
对于（int i=0；i0）{
提供（新MyHLeaf（FreqArray[i]，（char）i））；
}
}
while（trees.size（）>1）{
MyHTree FChild=trees.poll（）；
MyHTree-SChild=trees.poll（）；
树木。提供（新MyHNode（FChild，SChild））；
}
返回trees.poll（）；
}
公共静态void PrintMyHCode（MyHTree树，StringBuffer前缀）{
if（MyHLeaf的树实例）{
MyHLeaf叶=（MyHLeaf）树；
System.out.println（leaf.CharValue+“\t\t”+leaf.frequency+“\t\t”+前缀）；
} 
else if（MyHNode的树实例）{
MyHNode节点=（MyHNode）树；
前缀.append（'0'）；
PrintMyHCode（node.left，前缀）；
prefix.deleteCharAt（prefix.length（）-1）；
前缀.append（'1'）；
PrintMyHCode（node.right，前缀）；
prefix.deleteCharAt（prefix.length（）-1）；
}
}
}
抽象类MyHTree实现了可比较的{
公共int频率；
公共密树（int f）{
频率=f；
}
公共整数比较（MyHTree树）{
返回频率-tree.frequency；
}
}
类MyHLeaf扩展了MyHTree{
公共价值；
公共MyHLeaf（int f，char v）{
超级（f）；
CharValue=v；
}
}
类MyHNode扩展了MyHTree{
公共密树左，右；
公共MyHNode（MyHTree l，MyHTree r）{
超级（左频+右频）；
左=l；
右=r；
}
}

PrintMyHCode（）方法迭代左、右子树，直到找到leaft节点。如果树中有n个元素，那么该方法的复杂性将是O（n）

ImplementTree（）方法将数组中的值添加到树中，然后轮询它们的孩子。 如果数组中有n个元素： 1.此方法中for循环的复杂性为O（n），因为每个元素都直接添加到树中 2.假设每个节点至少有两个子节点，则该方法中while循环的复杂性为O（logn）

因此，采用大O表示法的ImplementTree（）方法的总时间复杂度为O（nlogn）

---

希望，这个答案对你有用。

恐怕不行。但也许你有编程方面的问题？那代码行吗？你甚至没有努力正确格式化你的代码…很抱歉，但我赶时间。帕万·库马尔完美地回答了我的问题，所以无论如何，谢谢你。