java實現tbf演算法

⑴ java 實現演算法

package huda.laogao.ON_20121216;
import java.util.*;
public class GetEquation {
ArrayList<Integer> params = null;// 進行加減的數，長度設為n
int result = 0;/隱早/ 結果
public GetEquation(ArrayList<Integer> params, int result) {
this.params = params;
this.result = result;
}
public void run() {
int size = params.size();
if (size == 1) {
if (params.get(0) == result)
System.out.println(result + "=" + result);
else
System.out.println("Invalid");
return;
}
int[][] matrix = getMatrix(size - 1);
int m = matrix.length;// 行數
int count = 0;// 記錄符合結果的組合數
for (int i = 0; i < m; i++) {
int now = params.get(0);// 進行加減的結果，初始為第一個值
// 從第二個數開始進行加或減，加的話就相當於該數乘上1，然後加到結果上，
// 減的就相當於該數乘上-1，然後加到結果上
for (int j = 1; j < size; j++) {
now += matrix[i][j - 1] * params.get(j);
}
// System.out.println(now);
// 判斷結果
if (now == result) {
count++;// 組合灶慧雀數加1
System.out.print(params.get(0));
for (int j = 1; j < size; j++) {
if (matrix[i][j - 1] == 1)
System.out.print("+" + params.get(j));
else
System.out.print("-" + params.get(j));
}// for j
System.out.println("=" + result);
}// if
}// for i
if (count == 0)
System.out.println("Invalid");
}
public int[][] getMatrix(int n) {
int m = (int) Math.pow(2, n);
int matrix[][] = new int[m][n];
for (int i = 0; i < n; i++) {
int num = (int) Math.pow(2, i + 1);
// 總共分 2^(i+1)塊，如i=0，即該矩陣的第一列，可分為2塊，上一塊取1，下一塊取-1
int size = (int) Math.pow(2, n - i - 1);
// 每塊的大小為2^(n-i-1)，如n=3，i=0，每塊的大小為4，即前4個為1，後4個為-1
int flag = 1;// 先為+
for (int j = 0; j < num; j++) {
for (int k = 0; k <碧彎 size; k++) {
matrix[k + j * size][i] = flag;
}
flag *= -1;
}
}
return matrix;
}

public void print(int[][] matrix) {
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + "\t");
}
System.out.println();
}
}

public static void main(String args[]) {
ArrayList<Integer> params = new ArrayList<Integer>();
params.add(1);
params.add(2);
params.add(3);
params.add(4);
int result = 10;
GetEquation ge = new GetEquation(params, result);
ge.run();
}
}

運行結果為：1+2+3+4=10
註：難點為獲取加減矩陣，可輔助print()函數幫助理解
望採納

⑵ java實現幾種常見排序演算法

下面給你介紹四種常用排序演算法：

1、冒泡排序

特點：效率低，實現簡單

思想（從小到大排）：每一趟將待排序序列中最大元素移到最後，剩下的為新的待排序序列，重復上述步驟直到排完所有元素。這只是冒泡排序的一種，當然也可以從後往前排。

⑶ java中遞歸演算法是什麼怎麼算的

一、遞歸演算法基本思路：

Java遞歸演算法是基於Java語言實現的遞歸演算法。遞歸演算法是一種直接或者間接調用自身函數或者方法的演算法。遞歸演算法實質是把問題分解成規模縮小的同類問題的子問題，然後遞歸調用方法表示問題的解。遞歸往往能給我們帶來非常簡潔非常直觀的代碼形式，從而使我們的編碼大大簡化，然而遞歸的思維確實跟我們的常規思維相逆的，通常都是從上而下的思維問題，而遞歸趨勢從下往上的進行思維。

二、遞歸演算法解決問題的特點：

【1】遞歸就是方法里調用自身。

【2】在使用遞歸策略時，必須有一個明確的遞歸結束條件，稱為遞歸出口。

【3】遞歸演算法代碼顯得很簡潔，但遞歸演算法解題的運行效率較低。所以不提倡用遞歸設計程序。

【4】在遞歸調用的過程中系統為每一層的返回點、局部量等開辟了棧來存儲。遞歸次數過多容易造成棧溢出等，所以一般不提倡用遞歸演算法設計程序。

【5】在做遞歸演算法的時候，一定把握出口，也就是做遞歸演算法必須要有一個明確的遞歸結束條件。這一點是非常重要的。其實這個出口就是一個條件，當滿足了這個條件的時候我們就不再遞歸了。

三、代碼示例：

publicclassFactorial{

//thisisarecursivefunction

intfact(intn){

if(n==1)return1;

returnfact(n-1)*n;

}}

publicclassTestFactorial{publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

Factorialfactorial=newFactorial();

System.out.println("factorial(5)="+factorial.fact(5));

}
}

代碼執行流程圖如下：

此程序中n=5就是程序的出口。

⑷ java十大演算法

演算法一：快速排序演算法
快速排序是由東尼·霍爾所發展的一種排序演算法。在平均狀況下，排序 n 個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他Ο(n log n) 演算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。

快速排序使用分治法（Divide and conquer）策略來把一個串列（list）分為兩個子串列（sub-lists）。

演算法步驟：

1 從數列中挑出一個元素，稱為 "基準"（pivot），

2 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱為分區（partition）操作。

3 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個演算法總會退出，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。

演算法二：堆排序演算法
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。

堆排序的平均時間復雜度為Ο(nlogn) 。

演算法步驟：

創建一個堆H[0..n-1]

把堆首（最大值）和堆尾互換

3. 把堆的尺寸縮小1，並調用shift_down(0),目的是把新的數組頂端數據調整到相應位置

4. 重復步驟2，直到堆的尺寸為1

演算法三：歸並排序
歸並排序（Merge sort，台灣譯作：合並排序）是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。

演算法步驟：

1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列

2. 設定兩個指針，最初位置分別為兩個已經排序序列的起始位置

3. 比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置

4. 重復步驟3直到某一指針達到序列尾

5. 將另一序列剩下的所有元素

⑸ 如何用JAVA實現字元串簡單加密解密

java加密字元串可以使用des加密演算法，實例如下：
package test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
/**
* 加密解密
*
* @author shy.qiu
* @since
*/
public class CryptTest {
/**
* 進行MD5加密
*
* @param info
* 要加密的信息
* @return String 加密後的字元串
*/
public String encryptToMD5(String info) {
byte[] digesta = null;
try {
// 得到一個md5的消息摘要
MessageDigest alga = MessageDigest.getInstance("MD5");
// 添加要進行計算摘要的信息
alga.update(info.getBytes());
// 得到該摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 將摘要轉為字元串
String rs = byte2hex(digesta);
return rs;
}
/**
* 進行SHA加密
*
* @param info
* 要加密的信息
* @return String 加密後的字元串
*/
public String encryptToSHA(String info) {
byte[] digesta = null;
try {
// 得到一個SHA-1的消息摘要
MessageDigest alga = MessageDigest.getInstance("SHA-1");
// 添加要進行計算摘要的信息
alga.update(info.getBytes());
// 得到該摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 將摘要轉為字元串
String rs = byte2hex(digesta);
return rs;
}
// //////////////////////////////////////////////////////////////////////////
/**
* 創建密匙
*
* @param algorithm
* 加密演算法,可用 DES,DESede,Blowfish
* @return SecretKey 秘密（對稱）密鑰
*/
public SecretKey createSecretKey(String algorithm) {
// 聲明KeyGenerator對象
KeyGenerator keygen;
// 聲明 密鑰對象
SecretKey deskey = null;
try {
// 返回生成指定演算法的秘密密鑰的 KeyGenerator 對象
keygen = KeyGenerator.getInstance(algorithm);
// 生成一個密鑰
deskey = keygen.generateKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 返回密匙
return deskey;
}
/**
* 根據密匙進行DES加密
*
* @param key
* 密匙
* @param info
* 要加密的信息
* @return String 加密後的信息
*/
public String encryptToDES(SecretKey key, String info) {
// 定義 加密演算法,可用 DES,DESede,Blowfish
String Algorithm = "DES";
// 加密隨機數生成器 (RNG),(可以不寫)
SecureRandom sr = new SecureRandom();
// 定義要生成的密文
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密鑰和模式初始化Cipher對象
// 參數:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1.init(Cipher.ENCRYPT_MODE, key, sr);
// 對要加密的內容進行編碼處理,
cipherByte = c1.doFinal(info.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
// 返回密文的十六進制形式
return byte2hex(cipherByte);
}
/**
* 根據密匙進行DES解密
*
* @param key
* 密匙
* @param sInfo
* 要解密的密文
* @return String 返回解密後信息
*/
public String decryptByDES(SecretKey key, String sInfo) {
// 定義 加密演算法,
String Algorithm = "DES";
// 加密隨機數生成器 (RNG)
SecureRandom sr = new SecureRandom();
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密鑰和模式初始化Cipher對象
c1.init(Cipher.DECRYPT_MODE, key, sr);
// 對要解密的內容進行編碼處理
cipherByte = c1.doFinal(hex2byte(sInfo));
} catch (Exception e) {
e.printStackTrace();
}
// return byte2hex(cipherByte);
return new String(cipherByte);
}
// /////////////////////////////////////////////////////////////////////////////
/**
* 創建密匙組，並將公匙，私匙放入到指定文件中
*
* 默認放入mykeys.bat文件中
*/
public void createPairKey() {
try {
// 根據特定的演算法一個密鑰對生成器
KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");
// 加密隨機數生成器 (RNG)
SecureRandom random = new SecureRandom();
// 重新設置此隨機對象的種子
random.setSeed(1000);
// 使用給定的隨機源（和默認的參數集合）初始化確定密鑰大小的密鑰對生成器
keygen.initialize(512, random);// keygen.initialize(512);
// 生成密鑰組
KeyPair keys = keygen.generateKeyPair();
// 得到公匙
PublicKey pubkey = keys.getPublic();
// 得到私匙
PrivateKey prikey = keys.getPrivate();
// 將公匙私匙寫入到文件當中
doObjToFile("mykeys.bat", new Object[] { prikey, pubkey });
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
/**
* 利用私匙對信息進行簽名 把簽名後的信息放入到指定的文件中
*
* @param info
* 要簽名的信息
* @param signfile
* 存入的文件
*/
public void signToInfo(String info, String signfile) {
// 從文件當中讀取私匙
PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);
// 從文件中讀取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);
try {
// Signature 對象可用來生成和驗證數字簽名
Signature signet = Signature.getInstance("DSA");
// 初始化簽署簽名的私鑰
signet.initSign(myprikey);
// 更新要由位元組簽名或驗證的數據
signet.update(info.getBytes());
// 簽署或驗證所有更新位元組的簽名，返回簽名
byte[] signed = signet.sign();
// 將數字簽名,公匙,信息放入文件中
doObjToFile(signfile, new Object[] { signed, mypubkey, info });
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 讀取數字簽名文件 根據公匙，簽名，信息驗證信息的合法性
*
* @return true 驗證成功 false 驗證失敗
*/
public boolean validateSign(String signfile) {
// 讀取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);
// 讀取簽名
byte[] signed = (byte[]) getObjFromFile(signfile, 1);
// 讀取信息
String info = (String) getObjFromFile(signfile, 3);
try {
// 初始一個Signature對象,並用公鑰和簽名進行驗證
Signature signetcheck = Signature.getInstance("DSA");
// 初始化驗證簽名的公鑰
signetcheck.initVerify(mypubkey);
// 使用指定的 byte 數組更新要簽名或驗證的數據
signetcheck.update(info.getBytes());
System.out.println(info);
// 驗證傳入的簽名
return signetcheck.verify(signed);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 將二進制轉化為16進制字元串
*
* @param b
* 二進制位元組數組
* @return String
*/
public String byte2hex(byte[] b) {
String hs = "";
String stmp = "";
for (int n = 0; n < b.length; n++) {
stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length() == 1) {
hs = hs + "0" + stmp;
} else {
hs = hs + stmp;
}
}
return hs.toUpperCase();
}
/**
* 十六進制字元串轉化為2進制
*
* @param hex
* @return
*/
public byte[] hex2byte(String hex) {
byte[] ret = new byte[8];
byte[] tmp = hex.getBytes();
for (int i = 0; i < 8; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
/**
* 將兩個ASCII字元合成一個位元組； 如："EF"--> 0xEF
*
* @param src0
* byte
* @param src1
* byte
* @return byte
*/
public static byte uniteBytes(byte src0, byte src1) {
byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 }))
.byteValue();
_b0 = (byte) (_b0 << 4);
byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 }))
.byteValue();
byte ret = (byte) (_b0 ^ _b1);
return ret;
}
/**
* 將指定的對象寫入指定的文件
*
* @param file
* 指定寫入的文件
* @param objs
* 要寫入的對象
*/
public void doObjToFile(String file, Object[] objs) {
ObjectOutputStream oos = null;
try {
FileOutputStream fos = new FileOutputStream(file);
oos = new ObjectOutputStream(fos);
for (int i = 0; i < objs.length; i++) {
oos.writeObject(objs[i]);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 返回在文件中指定位置的對象
*
* @param file
* 指定的文件
* @param i
* 從1開始
* @return
*/
public Object getObjFromFile(String file, int i) {
ObjectInputStream ois = null;
Object obj = null;
try {
FileInputStream fis = new FileInputStream(file);
ois = new ObjectInputStream(fis);
for (int j = 0; j < i; j++) {
obj = ois.readObject();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}
/**
* 測試
*
* @param args
*/
public static void main(String[] args) {
CryptTest jiami = new CryptTest();
// 執行MD5加密"Hello world!"
System.out.println("Hello經過MD5:" + jiami.encryptToMD5("Hello"));
// 生成一個DES演算法的密匙
SecretKey key = jiami.createSecretKey("DES");
// 用密匙加密信息"Hello world!"
String str1 = jiami.encryptToDES(key, "Hello");
System.out.println("使用des加密信息Hello為:" + str1);
// 使用這個密匙解密
String str2 = jiami.decryptByDES(key, str1);
System.out.println("解密後為：" + str2);
// 創建公匙和私匙
jiami.createPairKey();
// 對Hello world!使用私匙進行簽名
jiami.signToInfo("Hello", "mysign.bat");
// 利用公匙對簽名進行驗證。
if (jiami.validateSign("mysign.bat")) {
System.out.println("Success!");
} else {
System.out.println("Fail!");
}
}
}

⑹ 使用BF演算法在主串S中查找子串T第一次出現的位置。函數int search_BF(char*s,c

#include<stdio.h>#include<string.h>void main(){ int count_substr(char *str,char *sub_str); char string[100]; char sub_str[100]; printf("input a string:\n"); scanf("%s",string); printf("input the substring:\n"); scanf("%s",sub_str); char *str1,*str2; str1 = string; str2 = sub_str; printf("count = %d",count_substr(str1,str2));}int count_substr(char *str,char *sub_str){ int count = 0; int i,j; for(i=0;i<strlen(str);i++) { for(j=0;j<strlen(sub_str);j++) { if(*(sub_str+j)!=*(str+i+j)) break; } if(j==strlen(sub_str))count++; } return count;}

⑺ 用JAVA設計一個簡單的加密、解密演算法，用該演算法來實現對數據的加密、解密

簡單的?

用異或就可以了..!

importjava.util.Scanner;

publicclass加密
{
	privatestaticScannersc=newScanner(System.in);
	publicstaticvoidmain(String[]Args)
	{
		System.out.println("
		================字元串加密演示=====================
");
		init();
	}
	//初始化!
	privatestaticvoidinit()
	{
		for(;;)
		{
			char[]arr=input();
			jiaMi(arr,20140908);
			jiaMi(20140908,arr);
		}
		
	}
	//鍵盤錄取!
	privatestaticchar[]input()
	{
		Strings=sc.nextLine();
		inta=s.length();
		char[]arr=newchar[a];
		//char[]arr=s.toCharArray();
		for(inti=0;i<s.length();i++)
		{
			arr[i]=s.charAt(i);
		}
		returnarr;
	}
	//加密!!
	privatestaticvoidjiaMi(char[]arr,inta)
	{
		for(inti=0;i<arr.length;i++)
		{
			arr[i]=((char)(arr[i]^a));
		}
		System.out.println("加密完成!");
		print(arr);
	}
	//解密!!
	privatestaticvoidjiaMi(inta,char[]arr)
	{
		for(inti=0;i<arr.length;i++)
		{
			arr[i]=((char)(arr[i]^a));
		}
		System.out.println("解密完成");
		print(arr);
	}
	//列印!!
	privatestaticvoidprint(char[]arr)
	{
		for(inti=0;i<arr.length;i++)
		{
			System.out.print(arr[i]);
		}
		System.out.println("
=========================
");
	}
}

⑻ java數字圖像處理常用演算法

一 讀取bmp圖片數據

// 獲取待檢測圖像 數據保存在數組 nData[] nB[] nG[] nR[]中

public void getBMPImage(String source) throws Exception { clearNData(); //清除數據保存區 FileInputStream fs = null; try { fs = new FileInputStream(source); int bfLen = ; byte bf[] = new byte[bfLen]; fs read(bf bfLen); // 讀取 位元組BMP文件頭 int biLen = ; byte bi[] = new byte[biLen]; fs read(bi biLen); // 讀取 位元組BMP信息頭

// 源圖寬度 nWidth = (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;

// 源圖高度 nHeight = (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;

// 位數 nBitCount = (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;

// 源圖大小 int nSizeImage = (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;

// 對 位BMP進行解析 if (nBitCount == ){ int nPad = (nSizeImage / nHeight) nWidth * ; nData = new int[nHeight * nWidth]; nB=new int[nHeight * nWidth]; nR=new int[nHeight * nWidth]; nG=new int[nHeight * nWidth];鍵帶 byte bRGB[] = new byte[(nWidth + nPad) * * nHeight]; fs read(bRGB (nWidth + nPad) * * nHeight); int nIndex = ; for (int j = ; j < nHeight; j++){ for (int i = ; i < nWidth; i++) { nData[nWidth * (nHeight j ) + i] = ( & xff) << | (((int) bRGB[nIndex + ] & xff) << ) | (((int) bRGB[nIndex + ] & xff) << ) | (int) bRGB[nIndex] & xff; nB[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex]& xff; nG[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex+ ]& xff; nR[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex+ ]& xff;稿物蘆 nIndex += ; } nIndex += nPad; }// Toolkit kit = Toolkit getDefaultToolkit();// image = kit createImage(new MemoryImageSource(nWidth nHeight // nData nWidth));

/*螞冊 //調試數據的讀取

FileWriter fw = new FileWriter( C:\Documents and Settings\Administrator\My Documents\nDataRaw txt );//創建新文件 PrintWriter out = new PrintWriter(fw); for(int j= ;j<nHeight;j++){ for(int i= ;i<nWidth;i++){ out print(( * +nData[nWidth * (nHeight j ) + i])+ _ +nR[nWidth * (nHeight j ) + i]+ _ +nG[nWidth * (nHeight j ) + i]+ _ +nB[nWidth * (nHeight j ) + i]+ ); } out println( ); } out close();*/ } } catch (Exception e) { e printStackTrace(); throw new Exception(e); } finally { if (fs != null) { fs close(); } } // return image; }

二由r g b 獲取灰度數組

public int[] getBrightnessData(int rData[] int gData[] int bData[]){ int brightnessData[]=new int[rData length]; if(rData length!=gData length || rData length!=bData length || bData length!=gData length){ return brightnessData; } else { for(int i= ;i<bData length;i++){ double temp= *rData[i]+ *gData[i]+ *bData[i]; brightnessData[i]=(int)(temp)+((temp (int)(temp))> ? : ); } return brightnessData; } }

三 直方圖均衡化

public int [] equilibrateGray(int[] PixelsGray int width int height) { int gray; int length=PixelsGray length; int FrequenceGray[]=new int[length]; int SumGray[]=new int[ ]; int ImageDestination[]=new int[length]; for(int i = ; i <length ;i++) { gray=PixelsGray[i]; FrequenceGray[gray]++; } // 灰度均衡化 SumGray[ ]=FrequenceGray[ ]; for(int i= ;i< ;i++){ SumGray[i]=SumGray[i ]+FrequenceGray[i]; } for(int i= ;i< ;i++) { SumGray[i]=(int)(SumGray[i]* /length); } for(int i= ;i<height;i++) { for(int j= ;j<width;j++) { int k=i*width+j; ImageDestination[k]= xFF | ((SumGray[PixelsGray[k]]<< ) | (SumGray[PixelsGray[k]]<< ) | SumGray[PixelsGray[k]]); } } return ImageDestination; }

四 laplace 階濾波 增強邊緣 圖像銳化

public int[] laplace DFileter(int []data int width int height){ int filterData[]=new int[data length]; int min= ; int max= ; for(int i= ;i<height;i++){ for(int j= ;j<width;j++){ if(i== || i==height || j== || j==width ) filterData[i*width+j]=data[i*width+j]; else filterData[i*width+j]= *data[i*width+j] data[i*width+j ] data[i*width+j+ ] data[(i )*width+j] data[(i )*width+j ] data[(i )*width+j+ ] data[(i+ )*width+j] data[(i+ )*width+j ] data[(i+ )*width+j+ ]; if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } }// System out println( max: +max);// System out println( min: +min); for(int i= ;i<width*height;i++){ filterData[i]=(filterData[i] min)* /(max min); } return filterData; }

五 laplace 階增強濾波 增強邊緣 增強系數delt

public int[] laplaceHigh DFileter(int []data int width int height double delt){ int filterData[]=new int[data length]; int min= ; int max= ; for(int i= ;i<height;i++){ for(int j= ;j<width;j++){ if(i== || i==height || j== || j==width ) filterData[i*width+j]=(int)(( +delt)*data[i*width+j]); else filterData[i*width+j]=(int)(( +delt)*data[i*width+j] data[i*width+j ]) data[i*width+j+ ] data[(i )*width+j] data[(i )*width+j ] data[(i )*width+j+ ] data[(i+ )*width+j] data[(i+ )*width+j ] data[(i+ )*width+j+ ]; if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } } for(int i= ;i<width*height;i++){ filterData[i]=(filterData[i] min)* /(max min); } return filterData; } 六 局部閾值處理 值化

// 局部閾值處理 值化 niblack s method /*原理 T(x y)=m(x y) + k*s(x y) 取一個寬度為w的矩形框 (x y)為這個框的中心 統計框內數據 T(x y)為閾值 m(x y)為均值 s(x y)為均方差 k為參數(推薦 )計算出t再對(x y)進行切割 / 這個演算法的優點是 速度快 效果好 缺點是 niblack s method會產生一定的雜訊 */ public int[] localThresholdProcess(int []data int width int height int w int h double coefficients double gate){ int[] processData=new int[data length]; for(int i= ;i<data length;i++){ processData[i]= ; } if(data length!=width*height) return processData; int wNum=width/w; int hNum=height/h; int delt[]=new int[w*h]; //System out println( w; +w+ h: +h+ wNum: +wNum+ hNum: +hNum); for(int j= ;j<hNum;j++){ for(int i= ;i<wNum;i++){ //for(int j= ;j< ;j++){ //for(int i= ;i< ;i++){ for(int n= ;n<h;n++) for(int k= ;k<w;k++){ delt[n*w+k]=data[(j*h+n)*width+i*w+k]; //System out print( delt[ +(n*w+k)+ ]: +delt[n*w+k]+ ); } //System out println(); /* for(int n= ;n<h;n++) for(int k= ;k<w;k++){ System out print( data[ +((j*h+n)*width+i*w+k)+ ]: +data[(j*h+n)*width+i*w+k]+ ); } System out println(); */ delt=thresholdProcess(delt w h coefficients gate); for(int n= ;n<h;n++) for(int k= ;k<w;k++){ processData[(j*h+n)*width+i*w+k]=delt[n*w+k]; // System out print( delt[ +(n*w+k)+ ]: +delt[n*w+k]+ ); } //System out println(); /* for(int n= ;n<h;n++) for(int k= ;k<w;k++){ System out print( processData[ +((j*h+n)*width+i*w+k)+ ]: +processData[(j*h+n)*width+i*w+k]+ ); } System out println(); */ } } return processData; }

七 全局閾值處理 值化

public int[] thresholdProcess(int []data int width int height double coefficients double gate){ int [] processData=new int[data length]; if(data length!=width*height) return processData; else{ double sum= ; double average= ; double variance= ; double threshold; if( gate!= ){ threshold=gate; } else{ for(int i= ;i<width*height;i++){ sum+=data[i]; } average=sum/(width*height); for(int i= ;i<width*height;i++){ variance+=(data[i] average)*(data[i] average); } variance=Math sqrt(variance); threshold=average coefficients*variance; } for(int i= ;i<width*height;i++){ if(data[i]>threshold) processData[i]= ; else processData[i]= ; } return processData; } }

八 垂直邊緣檢測 sobel運算元

public int[] verticleEdgeCheck(int []data int width int height int sobelCoefficients) throws Exception{ int filterData[]=new int[data length]; int min= ; int max= ; if(data length!=width*height) return filterData; try{ for(int i= ;i<height;i++){ for(int j= ;j<width;j++){ if(i== || i== || i==height || i==height ||j== || j== || j==width || j==width ){ filterData[i*width+j]=data[i*width+j]; } else{ double average; //中心的九個像素點 //average=data[i*width+j] Math sqrt( )*data[i*width+j ]+Math sqrt( )*data[i*width+j+ ] average=data[i*width+j] sobelCoefficients*data[i*width+j ]+sobelCoefficients*data[i*width+j+ ] data[(i )*width+j ]+data[(i )*width+j+ ] data[(i+ )*width+j ]+data[(i+ )*width+j+ ]; filterData[i*width+j]=(int)(average); } if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } } for(int i= ;i<width*height;i++){ filterData[i]=(filterData[i] min)* /(max min); } } catch (Exception e) { e printStackTrace(); throw new Exception(e); } return filterData; }

九 圖像平滑 * 掩模處理（平均處理） 降低雜訊

⑼ 怎樣用Java實現網橋自學習演算法

網橋的自學習演算法原理

珞辰

網橋：在數據鏈路層可以用網橋設備來擴展乙太網。網橋工作在數據鏈路層，它根據MAC 幀的目的地址對收到的幀進行存儲轉發和過濾。當網橋收到一個數據幀時，並不是向所有的介面轉發這個數據幀，而是會進行有條件的轉發（網橋會丟棄CRC檢驗有差錯的幀以及幀長過短和過長的無效幀）再根據此幀的目的MAC地址，然後查找轉發表（網橋會自己維護轉發表，轉發表中每一條目都記錄了到達某個目的MAC地址的數據幀可以從那個介面進行轉發）根據轉發表中的條目逐步匹配看該從那個介面轉發或是否需要丟棄該數據幀。最簡單的網橋只有兩個介面（這里所講的網橋都是兩個介面的網橋）。

使用網橋設備的優點：

1，過濾通信量，增大吞吐量（網橋可以隔離碰撞域提高網路的吞吐量）

2，擴大了物理網路的范圍（擴展乙太網）

3，提供了可靠性（隻影響單個網段）

4，可以互連不同的物理層，不同MAC子層和不同速率

使用網橋設備的缺點：

1，使用CMSA/CD演算法增加了時延

2，不能進行流量控制，緩存存儲空間可能會發生溢出

3，會產生廣播風暴

網橋自學習和轉發幀的一般步驟：

1，網橋收到一幀後先進行自學習。查找轉發表中與收到數據幀的源地址有無匹配的項目。如果沒有，就在轉發表中增加一個項目（記錄數據幀的源地址，進入網橋的介面和時間）。如果有，則把原來的項目進行更新。

2，轉發幀。查找轉發表中與收到數據幀的目的地址有無相匹配的項目。如果沒有，則通過其他的介面（但進入網橋的介面除外）進行轉發。如果有，則按轉發表中給出的介面進行轉發。但應當注意，若轉發表中給出的介面就是該幀進入網橋的介面，則應該丟棄這個數據幀（因為這種情況不需要經過網橋進行轉發）。

3，使用生成樹演算法，即互連載一起的網橋在進行彼此通信後，就能找出原來的網路拓撲的一個子集。在這個子集里，整個連通的網路中不存在迴路，即在任何兩個站點之間只有一條路徑。

for example： 如圖所示，6個站點通過透明網橋B1和B2連接到一個擴展的區域網上。初始時網橋B1和B2的轉發表都為空。假設需要傳輸的幀序列如下：H2傳輸給H1；H5傳輸給H4；H3傳輸給H5；H1傳輸給H2；H6傳輸給H5。請給出這些幀傳輸完後網橋B1和網橋B2的轉發表。假設轉發表表項的格式為：[ 站點， 埠 ]。

發送的幀B1轉發表 B1的處理 B2轉發表 B2的處理

H2--->H1 H2，1 登記，轉發 H2，1 登記，轉發

H5--->H4 H5，2 登記，轉發 H5，2 登記，轉發

H3--->H5 H3，2 登記，丟棄 H3，1 登記，轉發

H1--->H2 H1，1 登記，丟棄

H6--->H5 H6，2 登記，丟棄

解釋說明：

1，H2主機向H1主機發送幀。連接在同一個區域網上的主機H1和網橋B1都能收到H2主機發送的數據幀。網橋B1收到這個數據幀後，先按源地址H2查找轉發表。這時因為網橋B1的轉發表為空，於是就把地址H2和收到此幀的介面1 寫入到轉發表中。這就表示，以後若收到要發給H2的幀，應當從網橋B1的這個介面1 轉發出去。接著再按目的地址H1查找轉發表。轉發表中沒有H1的地址，於是通過除收到此幀的介面1 以外的所有介面轉發此幀。網橋B2 從其介面1 收到這個轉發過來的幀。網橋B2按同樣的方式處理收到的幀。網橋B2的轉發表中沒有H2的地址，因此在網橋B2的轉發表中寫入地址H2 和介面1 。網橋B2的轉發表中沒有H1的地址，因此網橋B2會通過除接收此幀的介面1 以外的所有介面轉發這個幀。（H1本來就可以直接收到H2發送的數據幀，為什麼還要讓網橋B1和B2盲目地轉發這個幀呢？？？ 答案是：這兩個網橋當時並不知道網路的拓撲結構，因此要通過自學習過程才能逐步弄清所連接的網路拓撲，建立起自己的轉發表）

2，H3主機向H5主機發送數據幀。首先看網橋B1，網橋B1從其介面2收到這個數據幀。網橋B1的轉發表中沒有H3，因此在B1的轉發表中寫入地址H3 和介面2。再查找目的地址H5。現在網橋B1的轉發表中可以查詢到H5，其轉發的介面是2，和這個幀進入網橋B1的介面一樣。於是網橋B1知道，不用自己轉發這個幀，H5也能收到H3發送的幀。於是網橋B1把這個幀丟棄，不再繼續轉發了。再看網橋B2，網橋B2從其借口1 收到這個幀。網橋B2的轉發表中沒有H3，因此在B2的轉發表中寫入地址H3 和介面 1。再查找目的地址H5。現在網橋B2的轉發表中可以查詢到H5，其轉發的介面是 2 ，於是網橋B2直接將這個幀從介面2 轉發出去。

3，H6主機向H5主機發送數據幀。首先看網橋B2，網橋B2從其介面2 收到這個數據幀。網橋B2的轉發表中沒有H6，因此在B2的轉發表中寫入地址H6 和介面 2。再查找目的地址H5。現在網橋B2的轉發表中可以查詢到H5，其轉發的介面是2，和這個幀進入網橋B2的介面一樣。於是網橋B2知道，不用自己轉發這個幀，H5也能收到H6發送的幀。於是網橋B2把這個幀丟棄，不再繼續轉發了。再看網橋B1，其根本不會收到H6主機向H5發送的數據幀，所以不會有任何其他操作。

PS：在網橋的轉發表中寫入的信息除了地址和介面外，還有幀進入該網橋的時間。網橋中的介面管理軟體周期性的掃描轉發表中的項目。只要在一定時間以前登記的都要刪除。這樣就使得網橋中的轉發表能反映當前網路的最新拓撲狀態。還有一點網橋是一種工作在數據鏈路層的網路設備，它能對於接收到的數據幀進行有條件的轉發並且能隔離沖突域。

⑽ 關於各種排列組合java演算法實現方法

一 利用二進制狀態法求排列組合 此種方法比較容易懂 但是運行喊隱頌效率不高 小數據排列組合可以使用

//利用二進制演算法進行全排列 //count : //count :

public class test { public static void main(String[] args) { long start=System currentTimeMillis(); count (); long end=System currentTimeMillis(); System out println(end start); } private static void count (){ int[] num=new int []{ }; for(int i= ;i<Math pow( );i++){ String str=Integer toString(i ); int sz=str length(); for(int j= ;j< sz;j++){ str=" "+str; } char[] temp=str toCharArray(); Arrays sort(temp); String gl=new String(temp); if(!gl equals(" ")){ continue; } String result=""; for(int m= ;m<str length();m++){ result+=num[Integer parseInt(str charAt(m)+"")]; } System out println(result); } } public static void count (){ int[] num=new int []{ }; int[] ss=new int []{ }; int[] temp=new int[ ]; while(temp[ ]< ){ temp[temp length ]++; for(int i=temp length ;i> ;i ){ if(temp[i]== ){ temp[i]= ; temp[i ]++; } } int []tt=temp clone(); Arrays sort(tt); if(!Arrays equals(tt ss)){ continue; } String result=""; for(int i= ;i<num length;i++){ result+=num[temp[i]]; } System out println(result); } } }

二 用遞歸的思想攜慧來求排列跟組合 代碼量比較大

import java util ArrayList; import java util List;

public class Test {

/** * @param args */ public static void main(String[] args) { // TODO Auto generated method stub Object[] tmp={ }; // ArrayList<Object[]> rs=RandomC(tmp); ArrayList<Object[]> rs=cmn(tmp ); for(int i= ;i<rs size();i++) { // System out print(i+"="); for(int j= ;j<rs get(i) length;j++) { System out print(rs get(i)[j]+" "); } System out println(); } }

// 求一個數組的任意組合 static ArrayList<Object[]> RandomC(Object[] source) { ArrayList<Object[]> result=new ArrayList<Object[]>(); if(source length== ) { result add(source); } else { Object[] psource=new Object[source length ]; for(int i= ;i<psource length;i++) { psource[i]=source[i]; } result=RandomC(psource); int len=result size();//fn組合的長度 result add((new Object[]{source[source length ]})); for(int i= ;i<len;i++) { Object[] tmp=new Object[result get(i) length+ ]; for(int j= ;j<tmp length ;j++) { tmp[j]=result get(i)[j]; } tmp[tmp length ]=source[source length ]; result add(tmp); } } return result; } static ArrayList<Object[]> cmn(Object[] source int n) { ArrayList<Object[]> result=new ArrayList<Object[]>(); if(n== ) { for(int i= ;i<source length;i++) { result add(new Object[]{source[i]}); } } else if(source length==n) { result add(source); } else { Object[] psource=new Object[source length ]; for(int i= ;i<psource length;i++) { psource[i]=source[i]; } result=cmn(psource n); ArrayList<Object[]> tmp=cmn(psource n ); for(int i= ;i<tmp size();i++) { Object[] rs=new Object[n]; for(int j= ;j<n ;j++) { rs[j]=tmp get(i)[j]; } rs[n ]=source[source length ]; result add(rs); } } return result; }

}

三 利用動態規劃的思想求排列和組合

private static void count (int i String str int[] num) { if(i==num length){ System out println(str); return; } count (i+ str num); count (i+ str+num[i]+" " num); }

private static void count(int i String str int[] num int n) { if(n== ){ System out println(str); return; } if(i==num length){ return; } count(i+ str+num[i]+" " num n ); count(i+ str num n); } }

下面是求排列