唯一可译码判决准则

• 实验目的

  熟悉唯一可译码判决准则，掌握字符串处理程序的设计和调试技术。

• 实验要求

  已知：信源符号个数r、码字集合C。
  输入：任意的一个码。码字个数和每个具体的码字在运行时从键盘输入。
  输出：判决（是唯一可译码/不是唯一可译码）。

• 实验原理
  1、考查$C$中所有的码字，若${W_i}$是${W_j}$的前缀，则将相应的后缀作为一个尾随后缀码放入集合${F_0}$中；
  2、考察$C$和${F_i}$两个集合，若${W_i} \in C$是${W_i} \in {F_i}$的前缀或${W_i} \in {F_i}$是${W_j} \in C$的前缀，则将相应的后缀作为尾随后缀码放入集合${F_{i + 1}}$中；
  3、$F = \bigcup\limits_i {{F_i}}$即为码$C$的尾随后缀集合；
  4、若$F$中出现了$C$中的元素，算法终止，返回假（$C$不是唯一可译码）；否则若 F <script type="math/tex" id="MathJax-Element-17">F</script>中没有出现新的元素，则返回真。

• 实验程序

package com.yrwan.UDC;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
    public static void main(String[] args){
        ArrayList<String> ccString=new ArrayList<String>();//存储输入的码符号
        //输入字符
        if (args.length==0){
            ccString.clear();
            Scanner input = new Scanner(System.in);
            System.out.print("输入信源的个数：");
            int count = input.nextInt();
            System.out.print("输入编码符号：");
            for(int i = 0; i< count; i++)
            {
                ccString.add(input.next());
            }
            input.close();
            System.out.println("输入的码字是："+ccString);
        }else {
            Collections.addAll(ccString, args);
        }
        String result= UDC.compare(ccString)?"是唯一可译码":"不是唯一可译码";
        System.out.println(ccString+" "+result);
        System.exit(0);
    }
}

package com.yrwan.UDC;
import java.util.ArrayList;
public class UDC {
    private static boolean result=true;//默认是可唯一译码
    /*
     * 比较两个字符串str1、str2。若相等，即不可能是唯一可译码，使result为假
     * 若满足前缀关系，则返回后缀
     * 若无以上关系，返回真
     */
    private static String compareString(String str1,String str2)
    {
        String theResult=null;
        if(str1.equals(str2)){
            result=false;
        }
        if(result)
        {
            if(str1.startsWith(str2))
            {
                theResult=str1.substring(str2.length(),str1.length());
            }
            if(str2.startsWith(str1))
            {
                theResult=str2.substring(str1.length(),str2.length());
            }
        }
        return theResult;
    }
    /*
     * 比较两个集合a、b。若有相同的元素，则不是唯一可译码，使result为假
     * 若其中有元素满足前缀关系，则提取后缀添加到mylist中
     */
    private static void compareList(ArrayList<String> a,ArrayList<String> b,String endString)
    {
        boolean flag=false;
        String aa;
        String bb;
        cp: for(int i=0;i<a.size();i++)
        {
            for(int j=0;j<b.size();j++)
            {
                aa=a.get(i);
                bb=b.get(j);
                endString=compareString(aa,bb);
                if(!result)
                {
                    break cp;
                }
                if(endString!=null&&!b.contains(endString))
                {
                    b.add(endString);
                    flag=true;
                    break cp;
                }
            }
        }
        if(flag)
        {
            compareList(a,b,endString);
        }
    }
    /*
     * 对一个String集是否为唯一可译码给出判决
     */
    public static boolean compare(ArrayList<String> ccString){
        String endString=null;//用来引用要加入myList中的后缀
        ArrayList<String> myList=new ArrayList<>();
        //比较所给字符集中任何两个字符，将满足前后缀的字符添加到myList中
        cp: for(int m = 0; m< ccString.size(); m++)
        {
            for(int j = m+1; j< ccString.size(); j++)
            {
                String st1=ccString.get(m);
                String st2=ccString.get(j);
                endString= compareString(st1,st2);
                if(!result)
                {
                    break cp;
                }
                if(endString!=null&&!myList.contains(endString))
                {
                    myList.add(endString);
                }
            }
        }
        compareList(ccString,myList,endString);
        return result;
    }
}