清晰的唯一可译码判决准则

唯一可译码判决准则

已知：心愿符号个数r 、码字集合C

算法：

1、考查C 中所有的码字，若i W 是j W 的前缀，则将相应的后缀作为一个尾随后

缀码放入集合0F 中；

j j i 1i i i i i C F W C W F W F W C F +∈∈∈∈2、考查和两个集合，是的前缀或是的前缀，则将相应的后缀作为尾随后缀码放入集合中；

3、i i

F F = 即为码C 的尾随后缀集合； 4、若F 中出现了C 中的元素，则算法终止，返回假（C 不是唯一可译码）；否则若F 中没有出现新的元素，则返回真。

要求：

1、使用的编程：C++；

2、输入：任意的一个码，码字个数和每个具体的码字在运行时从键盘输入。

3、输出：判决（是唯一可译码/不是唯一可译码）。

4、源程序格式整齐清晰，注释简单明了。

创建C++工程和源文件：

代码如下：

#include

#include

#include

using namespace std;

struct strings

{char *string;

struct strings *next;

};

struct strings m_str, *m_h, *m_P;

inline int min(int a, int b)

{return a>b?b:a;}

inline int max(int a, int b)

{return a>b?a:b;}

#define length_a (strlen(CP))

#define length_b (strlen(tempPtr))

//判断一个码是否在一个码集合中，在则返回0，不在返回1

int Comparing(strings *st_string,char *code)

{

while(st_string->next)

{

st_string=st_string->next;

if(!strcmp(st_string->string,code))

return 0;

}

return 1;

}

//判断两个码字是否一个是另一个的前缀，如果是，则生成后缀码

void HZ(char *CP,char *tempPtr)

{

if (!strcmp(CP,tempPtr))

{

cout<<"判断结果：这个不是唯一可译码!"<

exit(1);

}

if (!strncmp(CP, tempPtr, min(length_a,length_b)))

{

struct strings *cp_temp;

cp_temp=new (struct strings);

cp_temp->next=NULL;

cp_temp->string=new char[abs(length_a-length_b)+1];

char *longstr;

longstr=(length_a>length_b ? CP : tempPtr); //将长度长的码赋给longstr

//取出后缀

for (int k=min(length_a,length_b); k

cp_temp->string[k - min(length_a,length_b)]=longstr[k];

cp_temp->string[abs(length_a-length_b)]=NULL;

//判断新生成的后缀码是否已在集合F里，不在则加入F集合

if(Comparing(m_h,cp_temp->string))

{

m_P->next=cp_temp;

m_P=m_P->next;

}

}

//主函数如下:

void main()

{

//提示

cout<<"唯一可译码的判别!"<

struct strings Cstr, *Ch, *CP,*tempPtr;

Ch=&Cstr;

CP=Ch;

m_h=&m_str;

m_P=m_h;

//输入待检测码的个数

int a;

cout<<"请输入码字符号的个数（输入后按回车键）："<

cin>>a;

if(cin.fail() || a<1)

{

cout<<"输入错误!请重新编译!"<

exit(1);

}

//输入待检测码

cout<<"请输入"<

for(int i=0; i

{

cout<

char tempstr[1];

cin>>tempstr;

CP->next=new (struct strings);

CP=CP->next;

CP->string=new char[strlen(tempstr)] ;

strcpy(CP->string, tempstr);

CP->next = NULL;

}

CP=Ch;

while(CP->next->next)

{

CP=CP->next;

tempPtr=CP;

do

{

tempPtr=tempPtr->next;

HZ(CP->string,tempPtr->string);

}while(tempPtr->next);

}

struct strings *Fbegin,*Fend;

Fend=m_h;

while(1)

{

if(Fend == m_P)

{

cout<<"判断结果：这个是唯一可译码！"<

exit(1);

}

Fbegin=Fend;

Fend=m_P;

CP=Ch;

while(CP->next)

{

CP=CP->next;

tempPtr=Fbegin;

for(;;)

{

tempPtr=tempPtr->next;

HZ(CP->string,tempPtr->string);

if(tempPtr == Fend)

break;

}

}

}

}

执行程序结果如下：

第一种情况：

输入：0

显示：输入错误!请重新编译!

如图：

第二种情况:

输入：4

然后输入4个码字：000，10，00，11 显示：这个不是唯一可译码！

如图：

第三种情况：

输入：4

然后输入4个码字：100，101，0，11 显示：这个是唯一可译码！

如图：