【中国大学MOOC】算法设计与分析-贪心策略-霍夫曼编码问题-Java

1. 问题描述：

2. 核心思想

提出贪心策略——证明策略正确

3. 算法伪代码

核心算法

3. Java代码实现

// huffMan Algorithm

import com.sun.source.tree.Tree;

import java.util.ArrayList;
import java.util.Objects;

class TreeNode{
    TreeNode left;
    TreeNode right;
    int val;
    TreeNode() {}
    TreeNode(int val) {this.val = val;}
    TreeNode(int val, TreeNode left, TreeNode right){
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public class huffMan {
    public static void main(String[] args){
        int[] input = {45,13,12,16,9,5};
        quickSortT(input, 0, input.length-1);
        ArrayList<TreeNode> P = new ArrayList<TreeNode>();
        ArrayList<TreeNode> Q = new ArrayList<TreeNode>();
        for (int value : input) {
            P.add(new TreeNode(value, null, null));
        }
        for(int i=0; i<input.length-1; i++){
            TreeNode z = new TreeNode();
            TreeNode x = extraceMin(P, Q);
            TreeNode y = extraceMin(P, Q);
            z.val = x.val + y.val;
            z.left = x;
            z.right = y;
            Q.add(z);
        }
        System.out.println(Objects.requireNonNull(extraceMin(P, Q)).val);

    }

    private static TreeNode extraceMin(ArrayList<TreeNode> P, ArrayList<TreeNode> Q){
        if(P.size() == 0 && Q.size()==0){
            return null;
        }
        TreeNode result = new TreeNode();
        if(P.size()>0){
            result.val = P.get(0).val;
        }else{
            result.val = Q.get(0).val;
        }

        for (TreeNode treeNode : P) {
            if (result.val > treeNode.val) {
                result = treeNode;
            }
        }
        for(TreeNode treeNode : Q){
            if(result.val > treeNode.val){
                result = treeNode;
            }
        }
        for(int i=0; i<P.size(); i++){
            if(result.val == P.get(i).val){
                P.remove(i);
                return result;
            }
        }
        for(int i=0; i<Q.size(); i++){
            if(result.val == Q.get(i).val){
                Q.remove(i);
                return result;
            }
        }
        return result;
    }

    // 从小到大 快速排序
    private static void quickSortT(int[] A, int start, int end){
        int i = start;
        int j = end;
        if(start < end){
            int tmp = A[start];
            while(i<j){
                while(i<j && tmp <= A[j]){
                    j--;
                }
                A[i] = A[j];
                while(i<j && tmp >= A[i]){
                    i++;
                }
                A[j] = A[i];
            }
            A[i] = tmp;
            quickSortT(A, start, i-1);
            quickSortT(A, i+1, end);
        }
    }
}