java内的Collections类自带了一个shuffle洗牌算法.
static void shuffle(List? list)
使用默认随机源对指定列表进行置换.
static void shuffle(List? list, Random rnd)
使用指定的随机源对指定列表进行置换.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
/**
文件名：FileEncrypter.java
说明：文件加密
加密方法：三重DES加密
加密过程：对选中的文件加密后在同文件夹下生成一个增加了".tdes"
扩展名的加密文件
解密过程：对选中的加密文件（必须有".tdes"扩展名）进行解密
*/
public class FileEncrypter extends JFrame{
public static void main(String args[]) {
FileEncrypter fe = new FileEncrypter();
fe.show();
}
FileEncrypter(){
this.setSize(WIDTH,HEIGHT);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setResizable(false);
Toolkit tk = Toolkit.getDefaultToolkit();
Dimension screenSize = tk.getScreenSize();
this.setTitle("文件加密器(TriDES)");
Container c = this.getContentPane();
c.setLayout( new FlowLayout());
final FilePanel fp = new FilePanel("文件选择");
c.add(fp);
final KeyPanel pp = new KeyPanel("密码");
c.add(pp);
JButton jbE = new JButton("加密");
c.add(jbE);
jbE.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent event){
File file = new File(fp.getFileName());
if (file.exists())
encrypt(file.getAbsoluteFile(),pp.getKey());
else
JOptionPane.showMessageDialog(
null,"请选择文件！","提示",JOptionPane.OK_OPTION);
});
JButton jbD = new JButton("解密");
c.add(jbD);
jbD.addActionListener(new ActionListener(){
decrypt(file.getAbsoluteFile(),pp.getKey());
加密函数
输入：
其中：
输出：
对输入的文件加密后,保存到同一文件夹下增加了".tdes"扩展名的文件中.
private void encrypt(File fileIn,String sKey){
try{
FileInputStream fis = new FileInputStream(fileIn);
byte[] bytIn = new byte[(int)fileIn.length()];
for(int i = 0;iFILEIN.LENGTH();I++){
bytIn[i] = (byte)fis.read();
//加密
byte[] bytOut = encryptByDES(encryptByDES(
String fileOut = fileIn.getPath() + ".tdes";
FileOutputStream fos = new FileOutputStream(fileOut);
for(int i = 0;iBYTOUT.LENGTH;I++){
fos.write((int)bytOut[i]);
fos.close();
this,"加密成功！","提示",JOptionPane.OK_OPTION);
}else
}catch(Exception e){
e.printStackTrace();
解密函数
对输入的文件解密后,保存到用户指定的文件中.
private void decrypt(File fileIn,String sKey){
String strPath = fileIn.getPath();
else{
this,"不是合法的加密文件！","提示",JOptionPane.OK_OPTION);
return;
JFileChooser chooser = new JFileChooser();
chooser.setCurrentDirectory(new File("."));
chooser.setSelectedFile(new File(strPath));
//用户指定要保存的文件
int ret = chooser.showSaveDialog(this);
if(ret==JFileChooser.APPROVE_OPTION){
//解密
byte[] bytOut = decryptByDES(decryptByDES(
File fileOut = chooser.getSelectedFile();
fileOut.createNewFile();
this,"解密成功！","提示",JOptionPane.OK_OPTION);
this,"解密失败,请核对密码！","提示",JOptionPane.OK_OPTION);
用DES方法加密输入的字节
private byte[] encryptByDES(byte[] bytP,byte[] bytKey) throws Exception{
DESKeySpec desKS = new DESKeySpec(bytKey);
SecretKeyFactory skf = SecretKeyFactory.getInstance("DES");
SecretKey sk = skf.generateSecret(desKS);
Cipher cip = Cipher.getInstance("DES");
cip.init(Cipher.ENCRYPT_MODE,sk);
return cip.doFinal(bytP);
用DES方法解密输入的字节
private byte[] decryptByDES(byte[] bytE,byte[] bytKey) throws Exception{
cip.init(Cipher.DECRYPT_MODE,sk);
return cip.doFinal(bytE);
输入密码的字符形式,返回字节数组形式.
private byte[] getKeyByStr(String str){
for(int i=0;iSTR.LENGTH()
Integer itg =
bRet[i] = itg.byteValue();
return bRet;
输入：0-F
private int getChrInt(char chr){
int iRet=0;
if(chr=="0".charAt(0)) iRet = 0;
if(chr=="1".charAt(0)) iRet = 1;
if(chr=="A".charAt(0)) iRet = 10;
if(chr=="B".charAt(0)) iRet = 11;
return iRet;
文件选择组件.
class FilePanel extends JPanel{
FilePanel(String str){
JLabel label = new JLabel(str);
JButton chooseButton = new JButton("浏览...");
this.add(label);
this.add(fileText);
this.add(chooseButton);
clickAction ca = new clickAction(this);
chooseButton.addActionListener(ca);
public String getFileName(){
JTextField jtf = (JTextField)this.getComponent(1);
return jtf.getText();
private class clickAction implements ActionListener{
clickAction(Component c){
cmpt = c;
int ret = chooser.showOpenDialog(cmpt);
JPanel jp = (JPanel)cmpt;
JTextField jtf = (JTextField)jp.getComponent(1);
jtf.setText(chooser.getSelectedFile().getPath());
private Component cmpt;
密码生成组件.
class KeyPanel extends JPanel{
KeyPanel(String str){
JButton chooseButton = new JButton("随机产生");
public String getKey(){
KeyGenerator kg = KeyGenerator.getInstance("DES");
Key ke = kg.generateKey();
byte[] bytK1 = ke.getEncoded();
ke = kg.generateKey();
private String getByteStr(byte[] byt){
String strRet = "";
for(int i=0;iBYT.LENGTH;I++){
//System.out.println(byt[i]);
return strRet;
private String getHexValue(int s){
String sRet=null;
switch (s){
case 0: sRet = "0";break;
case 1: sRet = "1";break;
case 10: sRet = "A";break;
case 11: sRet = "B";break;
return sRet;
挖掘频繁模式前首先要构造FP-Tree,算法为码如下：
输入:一个交易数据库DB和一个最小支持度threshold.
输出:它的FP-tree.
步骤:
①扫描数据库DB一遍.得到频繁项的集合F和每个频繁项的支持度.把F按支持度递降排序,结果记为L.
根据L中的顺序,选出并排序Trans中的事务项.把Trans中排好序的事务项列表记为[p|P],其中p是第一个元素,P是列表的剩余部分.调用insert_tree([p|P],T).
函数insert_tree([p|P],T)的运行如下.
如果T有一个子结点N,其中N.item-name=p.item-name,则将N的count域值增加1;否则,创建一个新节点N,使它的count为1,使它的父节点为T,并且使它的node_link和那些具有相同item_name域串起来.如果P非空,则递归调用insert_tree(P,N).
注：构造FP-Tree的算法理解上相对简单,所以不过多描述 对FP-Tree进行挖掘,算法如下：
输入:一棵用算法一建立的树Tree
输出:所有的频繁集
调用FP-growth(Tree,null).
procedure FP-Growth ( Tree, x)
{
(1)if (Tree只包含单路径P) then
#includestdio.h
#includestdlib.h
#includestring.h
#include"malloc.h"
#define L_size 100
typedef struct Nodeone
struct Nodeone *next;
}Nodeone,*TNodeone;
struct
/////////////////////////////////////////////
//栈的操作//////
typedef struct node
char data;
struct node * next;
}LinkStackNode,* LinkStack;
void InitStack(LinkStack * top)
(* top)=(LinkStack)malloc(sizeof(LinkStackNode));
(* top)-next=NULL;
//用头插法建栈
void Push(LinkStack top,char a)
LinkStackNode * temp;
temp=(LinkStackNode *)malloc(sizeof(LinkStackNode));
temp-data=a;
temp-next=top-next;
top-next=temp;
//删除栈顶元素
void Pop(LinkStack top,char *x)
temp=top-next;
top-next=temp-next;
*x=temp-data;
free(temp);
//////////////////////////////////////////////////////////////
////队列的操作////
typedef struct Node
struct Node * next;
}LinkQueueNode;
typedef struct
LinkQueueNode * front;
LinkQueueNode * rear;
}LinkQueue;
//链队列初始化
void InitQueue(LinkQueue *Q)
Q-front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
if(Q-front!=NULL)
Q-rear=Q-front;
Q-front-next=NULL;
//链队列入队操作
void EnterQueue(LinkQueue *Q,char x)
LinkQueueNode * NewNode;
NewNode=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
if(NewNode!=NULL)
NewNode-data=x;
NewNode-next=NULL;
Q-rear-next=NewNode;
Q-rear=NewNode;
//链队列出队操作
void DeleteQueue(LinkQueue *Q,char *x)
LinkQueueNode * p;
p=Q-front-next;
Q-front-next=p-next;
if(Q-rear==p)
*x=p-data;
free(p);
//读取文件
void read_rulefile()
FILE * fp;
char filename[LEN];
int i=0;
printf("请输入要打开规则文件的完整路径及其文件名：\n"); //1. 读取文本文件(rule.txt), 将具体规则的对应 关系读入数组或链表中
gets(filename);
fp=fopen(filename,"rt");
if(fp==NULL)
printf("\n打开文件失败,%s文件可能不存在\n",filename);
return ;
while(fscanf(fp,"%s %s",rule[i].rA,rule[i].ra)!=EOF)
printf("%s %s\n",rule[i].rA,rule[i].ra);
i++;
void read_meanfile()
while(fscanf(fp,"%s %s",mean[i].mA,mean[i].ma)!=EOF)
printf("%s %s\n",mean[i].mA,mean[i].ma);
///////////////////////////////////////////////////////////////////////
//思想：当没遇到闭括号时,一直压栈（top栈）.一旦遇到闭括号,首先找到与这个闭括号最近的匹配的开括号
//找到这两个括号"（" "）"之间的第一个 字符
//利用队列（Q 入队）以及（top栈 出栈）完成转换,再把转换后的队列,添加到（top栈中）把剩余的字符 原样添加到top栈中
//在把top栈 逆置到 top1栈中
//再利用top1栈出栈,给L重新赋值.
//递归,看L中是否还有括号
int i=0,j;
char * a;
char first;
a=(char *)malloc(sizeof(char));
InitStack(top);
InitQueue(Q);//辅助用来输出括号内的内容
InitStack(top1);
while(L[i]!=')'L[i]!='\0')
Push(top,L[i]);//当不等于'）'时,往top栈中压.
if(L[i]==')') //当等于'）'时
j=i;
while(L[j]!='(')
{ j--;
if(L[j]=='(')
j++;break;
first=L[j];//找到当前'（ '内的第一个字符
for(;ji-1;j++)
EnterQueue(Q,first);
Pop(top,a);
EnterQueue(Q,*a);
Pop(top,a); //这个是括号内的第一个字符
Pop(top,a);//把'（'删掉
while(Q-front-next!=NULL)
DeleteQueue(Q,a);
Push(top,*a);
}// if
i++;//跳过'）'
while(L[i]!=NULL)
{ Push(top,L[i]);
while(top-next!=NULL)
Push(top1,*a);
i=0;
while(top1-next!=NULL)
Pop(top1,a);
L[i]=*a;
L[i]=NULL;
i=0;j=0;
if(L[i]=='(' || L[i]==')')
j++;
if(j==0) return;
/////////////////////////////////////////////////////////////
//实现提示： 处理规则形式（1） 问题并没有规定具体规则的数量,
//比如增加 一条具体规则 C→eB 那么对魔王语言就要多处理一次,
//所以呢处理 规则形式（1）时需要递归处理,当语言中没有 大写字母后递归结束.
void tackle_1(char L[],LinkQueue * Q)
int i=0,j,z;
int k=0;
{ z=0;
if(L[i]==rule[j].rA[0])
{ k=0;
z=1;
while(rule[j].ra[k]!=NULL)
EnterQueue(Q,rule[j].ra[k]);
k++;
if(z==1)
EnterQueue(Q,L[i]);
L[i]=(*a);
i=0; j=0;
if(L[i]='A' L[i]='Z')
if(j==0)return;
else tackle_1(L,Q);
{ TNodeone head,r,s;
int j;
head=(Nodeone*)malloc(sizeof(Nodeone));
head-next=NULL;
r=head;
if(L[i]==mean[j].mA[0])
printf("%s",mean[j].ma);
s=(Nodeone*)malloc(sizeof(Nodeone));
strcpy(s-a,mean[j].ma);
r-next=s;
r=s;
r-next=NULL;
return head;
void savefile(TNodeone head)
{ FILE *fp;
TNodeone h;
h=head-next;
fp=fopen("c:/result.txt","wb");
{ printf("读文件失败,按任意键退出！");
getchar();
exit(1);
for(;h;h=h-next)
fprintf(fp,"%s",h-a);
fclose(fp);
printf("\n");
printf("保存文件成功！");
void main()
{ TNodeone head;
read_rulefile();
read_meanfile();
char L[L_size]; //魔王说的话
printf("请输入魔王语言：\n");
scanf("%s",L);
LinkStackNode * top, * top1;
top=(LinkStackNode * )malloc(sizeof(LinkStackNode));
top1=(LinkStackNode * )malloc(sizeof(LinkStackNode));
LinkQueue *Q;
Q=(LinkQueue *)malloc(sizeof(LinkQueue));
printf("魔王要说的话是：%s\n",L);
tackle_1(L,Q);
printf("魔王要说的话是（转换成小写后）：%s\n",L);
savefile(head);
FP—tree由标记为"null"的一个根节点(root)、作为根节点之子节点的项前缀子树(item prefix subtrees)的集合、和—个频繁项头表(frequent item header table)所组成.
频繁项头表包含两个域：Item_name和head of node_link. head of node_link指向FP—tree中具有相同Item_name的第一个节点.
根据FP_tree 的定义,我们得到FP_tree的构造方法
FP—tree是通过两次扫描事务集建立的.
(1)扫描事务集D,获得D中所包含的全部频繁项集合F,及它们各自的支持度.对F中的频繁项按其支持度降序排序,结果记为L；
FP—tree被建立后,频繁模式是采用下面的FP—growth方法对FP—tree进行挖掘得到的. Procedure FP_growth(Tree,a)//tree为a的条件模式树,a为后缀项(集)
{ if Tree 仅含一条路径P then
for 路径P中节点的每个组合(记作?) do
产生模式?Ua、并且把它的支持度supcoun指定为?中节点的最小支持度
else for 对Tree的头表从表尾到表头的每一个表项（记为a1）do {
产生一个模式?=a1Ua,其支持度计数supcount=a1．supcount：
创建?的条件模式基,然后构造?的条件模式树FP—tree? ；
if FP—tree ?= !+ then 调用FP_growth(FP—tree?、?)}
程序在定义数据结构和实现算法的时候主要考虑一下因素.
首先速度.速度问题在频繁集产生的算法中应该是比较重要的.因为它们常常涉及大量数据的处理.所以呢在程序中许多需要排序的数据结构都使用了平衡树,这是一种高效的对全序元素的组织方式.
其次,空间.同样因为要处理大量的数据,所以对内存的管理要尤其严格,如果出现内存泄漏将是很麻烦的事情.
第三,编程风格的考虑.要尽量采用通用化的代码.因为对于一个比较大的系统来说,任何一个小的部分都应该清楚明白,便于别人阅读和修改.
基于上面三点,在对程序的数据结构的定义和算法的实现的时候大量采用了C++的标准模板库(STL,Standard Template Library).这是基于以下的事实,关联规则的挖掘所涉及到的数据结构和基本算法都是以往的常用数据结构和算法,如向量类,集合类,快速排序算法等.而STL正是包含了这样许多通用的数据结构和基本算法的库.
例如,在STL中有一大类模板叫容器模板(container),简单的说就是包含了许多元素的类的模板,象vector,array,set等就属于容器模板.对于这些模板中的元素的访问都可以通过它们的遍历子,用完全一致的方式进行.请看下面两段程序清单：
void print(FreqSet* pSet){
FreqSet_Iter fit;
for(fit=pSet-begin();fit!=pSet-end();fit++){
printf("%s %d \n",(*fit).second.name,(*fit).second.count);
void print(Table* pTable){
Table_Iter tit;
for(tit=pTable-begin();tit!=pTable-end();tit++){
printf("%s %d \n",(*tit).name,(*tit).count);
这两个函数的作用是在调试的时候分别打印出频繁集pSet和头表pTable中的元素.
尽管pSet的类FreqSet是由map模板生成的,pTable的类Table是由multiset生成的,但对它们的元素的访问形式几乎一模一样都是利用相应的遍历子.涉及的函数名也很相似.其实,所有的容器模板都定义了函数begin()和end()代表元素列表的起始和结束.另外还有大量的具有相同名字和类似功能的函数,方便了我们对数据结构的管理.
在选择数据库访问方式的时候,用了最近比较流行的ADO方式,它比ODBC更加灵活,速度也有改善.对网络数据库的支持也很好.
对应于算法描述中所出现的各个对象分别定义了一些数据结构,仅以trans为例说明
class Trans:public std::vectorItem
public:
int TID;
Trans(){TID=0;};
Trans(int t){
TID=t;
bool operator==(const Trans right);
bool operator(const Trans right);
typedef Trans::iterator Trans_Iter;
Trans类对应于交易对象(Transaction).对它的定义利用了STL中的vector模板,把它定义为一个以Item为元素的向量.把它定义为向量,是因为后来需要对其中的元素进行排序,向量可以使用快速排序.
这个Trans 类身肩两任,它不仅代表事务对象,还在最后的结果输出中还被用来存放频繁集.
Trans_Iter是Trans类的遍历子.在以后使用STL容器模板定义的类都会有一个与之相对应的遍历子,不再赘述.
//根据条件模式库来生成用于构建条件树的频繁项
void FPTree::BuildCPTree(long p_Frequnce)
std::vectorstd::vectorassociate ::iterator it_CPBase=m_CPBase.begin();
std::vectorassociate::iterator it_vector,it_temp1;
std::mapstd::string,int Item_include;//包含非频繁的项的集合
std::mapstd::string,int::iterator it_map,it_temp;
std::string l_string;
long Frequnce=p_Frequnce;
bool flag=true;
int l_test;
//统计每个项目的频繁度
for (;it_CPBase!=m_CPBase.end();it_CPBase++)
it_vector=(*it_CPBase).begin();
while (it_vector!=(*it_CPBase).end())
l_string=(*it_vector).chr;
l_test=(*it_vector).num;
if (Item_include.count(l_string))
Item_include[l_string]+=(*it_vector).num;
l_test=Item_include[l_string];
Item_include[l_string]=(*it_vector).num;
it_vector++;
//除去map中的非频繁项
bool flag1=true;
it_map=Item_include.begin();
while ((it_map!=Item_include.end()) flag1)
l_string=it_map-first;
l_test=it_map-second;
if (it_map-second Frequnce)
it_temp=it_map;
it_map++;
Item_include.erase(it_temp);
if (it_map==Item_include.end())
flag1=false; }
if (!Item_include.empty())
以上就是土嘎嘎小编为大家整理的fp树算法java代码相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！