1. Basic introduction

Huffman tree, alias "Huffman tree", "Huffman tree", "optimal tree" and "optimal binary tree"

Given n weights as n leaf nodes, a binary tree is constructed. If the weighted path length (wpl) of the tree reaches the minimum, such a binary tree is called the optimal binary tree, also known as Huffman tree. Other books are translated as Huffman tree.

Huffman tree is the tree with the shortest weighted path length, and the node with larger weight is closer to the root.

Several important concepts and examples of Huffman tree
 Path and path length:
 In a tree, the path between children or grandchildren that can be reached from one node down is called path.
 The number of branches in a path is called the path length. If the specified number of layers of the root node is 1, the path length from the root node to the Lth layer node is L1
 Node weight and weighted path length:
 If a node in the tree is assigned a value with a certain meaning, this value is called the weight of the node.
 The weighted path length of a node is the product of the path length from the root node to the node and the weight of the node
 Weighted path length of the tree: the weighted path length of the tree is specified as the sum of the weighted path lengths of all leaf nodes, which is recorded as WPL(weighted path length). The binary tree with greater weight and closer to the root node is the optimal binary tree.
 The smallest WPL is Huffman tree
 Path and path length:
2. The idea of creating Huffman tree

A sequence {13,7,8,3,29,6,1} is required to be transformed into a Huffman tree

The steps of constructing Huffman tree;
 Sort from small to large. Each data is a node, and each node can be regarded as the simplest binary tree
 Take out the two binary trees with the smallest weight of the root node
 Form a new binary tree. The weight of the root node of the new binary tree is the sum of the weight of the root node of the previous two binary trees
 Then sort the new binary tree again according to the weight of the root node, and repeat the steps of 1234 until all the data in the sequence are processed to get a Huffman tree
3. Code implementation
//Huffman tree creation public class HuffmanTree { public static void main(String[] args) { int[] arr = {13, 7, 8, 3, 29, 6, 1}; Node root = createHuffmanTree(arr); //test preOrder(root); } //Write a preorder traversal method public static void preOrder(Node root){ if(root != null){ root.preOrder(); }else{ System.out.println("It is an empty tree and cannot be traversed"); } } //Method of creating Huffman tree /** * * @param arr You need to create an array into a Huffman tree * @return The root node of the created Huffman tree */ public static Node createHuffmanTree(int[] arr) { //1. For easy operation //1.1 traversing arr array //1.2 form each element of arr into a Node //1.3 put Node into ArrayList List<Node> nodes = new ArrayList<>(); for (int value : arr) { nodes.add(new Node(value)); } while (nodes.size() > 1) { //Sort from small to large Collections.sort(nodes); System.out.println("nodes =" + nodes); //Take out the two binary trees with the smallest weight of the root node //(1) Take out the node with the smallest weight (binary tree) Node leftNode = nodes.get(0); //(2) Take out the node with the second smallest weight (binary tree) Node rightNode = nodes.get(1); //(3) Construct a new binary tree Node parent = new Node(leftNode.value + rightNode.value); parent.left = leftNode; parent.right = rightNode; //(4) Deleted binary tree from ArrayList nodes.remove(leftNode); nodes.remove(rightNode); //(5) Add parent to nodes nodes.add(parent); } //Return Huffman's root node return nodes.get(0); } } //Create node class //To make the Node object support sorting Collections collection sorting //Let Node implement Comparable interface class Node implements Comparable<Node> { int value; //Node weight Node left; //Point to left child node Node right; //Point to the right child node //Preorder traversal public void preOrder() { System.out.println(this); if (this.left != null) { this.left.preOrder(); } if (this.right != null) { this.right.preOrder(); } } public Node(int value) { this.value = value; } @Override public String toString() { return "Node{" + "value=" + value + '}'; } @Override public int compareTo(Node o) { //Indicates sorting from small to large. If sorting from large to small, take negative [ (this.value  o.value)] return this.value  o.value; } }