archenemy求属性集的闭包和求候选键的2个算法(JAVA实现)

2021年1月19日发(作者：裘克安)
//
本程序实现了《数据库原理》课程中的
2
个算法

//1

求属性集的闭包

//2
求候选键


//
如执行


java

Closure
//
则验证第一个算法，即教材
4.1


求属性集的闭包


//
如执行


java

Closure

2
//
则验证第
2
个算法



即可教材
4.2

求候选键


import .*;
class

funsdepend{

ArrayList cols=new ArrayList();

//
输入的属性列集合

HashMap funs=new HashMap(); //
输入的函数依赖集合


ArrayList keys=new ArrayList(); //
求得的候选键集合


//
输入属性列

void inputCols(){
(); //
清空旧数据

n(
请输入单字母表示的属性列，一次可输入多列（如ABC)
，可多次输入，
输入
end
则结束输入

Sca nner in=new Scanner();
while (t()){




String str=ne();




if (rCase().equals(




for (int i=0; i<();i++){








//
依次取出每个字母








String s=ing(i,i+1).toUpperCase();







//
不重复地添加到
cols
中








if (!ns(s))



(s);




}
}
}

//
输入函数依赖

void inputFuns(){




();//
清空旧数据





n(< br>请输入形如
AB-C
的函数依赖，一次可输入多个
(
如
A-B ,B-C)
，输入
end
则结束输出





Scanner in=new Scanner();


while (t()){




String str=ne();


万发供求网





if (rCase().equals(




String[] fs=(
约定用
,
分开连续输入的多个函数依赖





for (String fun:fs){







String[] s=(
预定用
-
分开单个依赖的左边、右边








if (==2)









(s[0].toUpperCas e(),s[1].toUpperCase());//
将每个函数依赖以名值对的形式
存入
HashMap




}
}
}

//
测试
str1
中的每个字符是否都包含在
str2< br>中

//
例如

isInclude(
则返回
true
boolean isInclude(String str1,String str2){


boolean flag=true;


for(int i=0;i<();i++){





if ( f((i))==-1 ) {










flag=false;










break;






}


}


return flag;
}

//
将
small
中的每个字符不重复地加入到
big
中

//
例如

addStr(
则返回
ABCE
String addStr(String small,String big){


String str=big;


for(int i=0;i<();i++){





if ( f((i))==-1 ) {










str=str+ing(i, i+1);






}


}


return str;
}

//
计算属性闭包

//
参数

col:
待计算的属性列组合


fs:
以
HashMap
表示的函数依赖集

String getClosure(String col,HashMap fs){
String result=rCase();
boolean bflag=true;
while (bflag){




bflag=false;



for(String s: ()){


万发供求网








//
依次取出每个函数依赖的左部








//
如果左部包含在已求出的闭包中







if (isInclude(s,result)) {










//
则将函数依赖的右部也放入闭包中




String str=addStr((s),result);










if (!(str)) {














//
如果放入右部后，闭包有变化，则更新闭包















result=str;





//
并设置需要再次循环的标志















bflag=true;










}






}




}
}

return result;
}

//
可多次重复测试算法
4.1

void S41(){
n(
请输入要计算属性闭包的列组合
,
形如
AB
，输入
end
则结束

Scanner in=new Scanner();
while (t()){




String str=ne();




if (rCase().equals(




String s=getClosure(str,funs);




n(str+
属性集的闭包为：


n(




n(
请继续输入要计算属性闭包的列组合
,
形如
AB
，输入
end
则结束

}
}


//
输出属性列和函数依赖

void outputCols_Funs(){




(
属性列为
t:




n(cols);




(
依赖集为
t:




n(funs);



}

//
测试算法
4.1
void testS41(){



inputCols(); //
输入属性列




inputFuns(); //
输入函数依赖



万发供求网




outputCols_Funs();//
输出属性列和函数依赖




S41();
}

//
测试算法
4.2
求候选键

void S42(){



String allleft=



for(String s: ()){







allleft=allleft+s;











//
所有函数依赖的左部








allright=allright+(s);//
所有函数依赖的右部




}




//
依次代表
L
类，

LR
类
,








N
类




String lefts=




String allcol=
所有的列





for(String s: cols){







allcol=allcol+s;







if ((ns(s)) && (!ns(s)))








lefts=lefts+s;

//
只在左部出现，没有在右部出现，归入
lefts







else

if ((ns(s)) && (ns(s)))













leftrights=leftrights+s;

//
在左部、右部都出现，归入
leftrights








else

if ((!ns(s)) && (!ns(s)))













nolfs=nolfs+s;










//
在左部、右部都没有出现，归入
nolfs



}




n(
类是：




n(
类是：




n(
类是：





(); //keys
用于存放求出的多个候选键





String s=getClosure(lefts+nolfs,funs);



if (isInclude(allcol,s)){







//
如果
L/N
类的 闭包已含有全部属性列，则
L/N
类的组合是唯一候选键








n(
唯一候选键是
:







(lefts+nolfs);







return;



}




char[] lrs=Array() //
将
LR
列转为字符数组










万发供求网