A. 2021年你讀了哪些覺得比較好的計算機書籍
[美] 馬丁·福勒（Martin Fowler） 著，徐昊，鄭曄，熊節 譯
領域特定語言DSL，通過java和C語言分析具體案例，講解DSL的構造方式和通用原則，軟體開發程序員的教程，馬丁·福勒新的力作。
《領域特定語言》是領域特定語言（Domain-Specific Language，DSL）領域的豐碑之作，由軟體開發大師馬丁·福勒（Martin Fowler）歷時多年寫作而成。
全書共57章，分為6個部分，全面介紹了DSL概念、DSL常見主題、外部DSL主題、內部DSL主題、備高段選計算模型以及代碼生成等內容，揭示了與編程語言無關的通用原則和模式，闡釋了如何通過DSL有效提高開發人員的生產力以及增進與領域專家的有效溝通，能為開發人員選擇和使用DSL提供有效的決策依據和指導方法。
本書適合想要了解各種DSL及其構造方式，理解其通用原則、模式和適用場景，以提高開灶念州發生產力和溝通能力的軟體開發人員閱讀。
[美] 肯尼思·，A.蘭伯特（Kenneth，A.，Lambert，） 著，肖鑒明 譯
數據結構演算法入門教程，基於python語言進行講解，國外高等院校教材升級，書中包含大量習題和編程項目，隨書贈送配套資源。
本書用 Python 語言來講解數據結構及實現方法。全書首先概述 Python 編程的功能—這些功能是實際編程和解決問題時所必需的；其次介紹抽象數據類型的規范、實現和應用，多項集類型，以及介面和實現之間的重要差異；隨後介紹線性多項集、棧、隊列和列表；最後介紹樹、圖等內容。本書附有大量的復習題和編程項目，旨在幫助讀者鞏固所學知識。
本書不僅適合高等院校計算機專業師生閱讀，也適合對 Python 感興趣的讀者和程序員閱讀。
喬恩·克萊因伯格（Jon Kleinberg） 著，王海鵬 譯
用實際示例闡明枯燥的演算法理論，更注重演算法設計思維的培養，適合作為演算法入門書。
這是一本被眾多名校採用的演算法設計課程教材，強調用實際示例闡明枯燥的演算法理論，更注重演算法設計思路而非演算法復雜度分析。本書採用新穎的教學方式，通過分析真實世界的問題來激發演算法思想。兩位作者以一種清晰、直接的方式，指導學生自己分析和定義問題，並從中找出適用於給定場景的演算法設計原則。本書鼓勵讀者更深入地理解演算法設計過程， 探索 演算法在計算機科學的更廣闊領域中的應用。
本書具有以下特色：
王爭著
20個數據結構與演算法，100個真實項目場景案例，300多幅演算法手繪圖解
本書分為11章。第1章介紹復雜度分析方法。第2章介紹數組、鏈表、棧和隊列這些基礎的線性表數據結構。第3章介紹遞歸編程技巧、8種經典排序、二分查找及二分查找的變體問題。第4章隱蔽介紹哈希表、點陣圖、哈希演算法和布隆過濾器。第5章介紹樹相關的數據結構，包括二叉樹、二叉查找樹、平衡二叉查找樹、遞歸樹和B+樹。第6章介紹堆，以及堆的各種應用，包括堆排序、優先順序隊列、求Top K、求中位數和求百分位數。第7章介紹跳錶、並查集、線段樹和樹狀數組這些比較高級的數據結構。第8章介紹字元串匹配演算法，包括BF演算法、RK演算法、BM演算法、KMP演算法、Trie樹和AC自動機。第9章介紹圖及相關演算法，包括深度優先搜索、廣度優先搜索、拓撲排序、Dijkstra演算法、Floyd演算法、A*演算法、Z小生成樹演算法、Z大流演算法和Z大二分匹配等。第10章介紹4種演算法思想，包括貪心、分治、回溯和動態規劃。第11章介紹4個經典項目中的數據結構和演算法的應用，包括Redis、搜索引擎、鑒許可權流和短網址服務。另外，附錄A為書中的思考題的解答。
[美] 阿爾·斯維加特（Al Sweigart） 著
Python編程從入門到實踐姊妹篇，零基礎自學Python教程書籍，提供配套同步教學視頻、在線編程環境！針對Python3.X版本更新
在本書中，你將學習利用Python編程在幾分鍾內完成手動需要幾小時的工作，無須事先具備編程經驗。通過閱讀本書，你會學習Python的基本知識， 探索 Python豐富的模塊庫，並完成特定的任務（例如，從網站抓取數據，讀取PDF和Word文檔等）。本書還包括有關輸入驗證的實現方法，以及自動更新CSV文件的技巧。一旦掌握了編程的基礎知識，你就可以毫不費力地創建Python程序，自動化地完成很多繁瑣的工作，包括:
何華平 著
Python編程零基礎入門實踐教程，用Python處理Excel、Word、PPT、PDF、圖像文件，提升職場辦公效率，解決辦公難題，附贈學習資源和教學視頻
這是一本關於如何利用Python提高日常辦公效率的書，書中凝聚了作者多年的實踐經驗和獨特思考，旨在幫助讀者准確、高效地完成大量高重復度的工作。
《學Python，不加班：輕松實現辦公自動化》匯集了日常辦公和處理文檔時常見的問題，通過實例的演示與講解，幫助讀者靈活有效地使用Python處理工作中遇到的問題。全書共11章，涵蓋Python的各種應用場景，具體包括文件管理自動化，網路信息自動獲取，TXT、XLS／XLSX、DOC／DOCX、PPT、PDF、圖片文件的自動化處理，模擬滑鼠、鍵盤操控本地軟體，自動化運行管理等。本書力圖淡化編程中的抽象概念，貼合工作場景，注重實戰效果，通過對Python技術的巧妙講解，幫助讀者成為高效率的辦公室「超人」。
雷明 著
人工智慧深度學習領域教程，AI程序員的數學參考書，透徹理解機器學習演算法，從數學層面搞懂核心演算法原理的邏輯，python程序講解
本書的目標是幫助讀者全面、系統地學習機器學習所必須的數學知識。全書由8章組成，力求精準、最小地覆蓋機器學習的數學知識。包括微積分，線性代數與矩陣論，最優化方法，概率論，資訊理論，隨機過程，以及圖論。本書從機器學習的角度講授這些數學知識，對它們在該領域的應用舉例說明，使讀者對某些抽象的數學知識和理論的實際應用有直觀、具體的認識。 本書內容緊湊，結構清晰，深入淺出，講解詳細。可用作計算機、人工智慧、電子工程、自動化、數學等相關專業的教材與教學參考書。對人工智慧領域的工程技術人員與產品研發人員，本書也有很強的參考價值。對於廣大數學與應用的數學愛好者，本書亦為適合自學的讀本。
張逸 著
DDD領域驅動設計教程，進一步精化領域驅動設計方法體系，通過實戰案例演示統一過程的實施，可幫助讀者提高領域建模及軟體設計能力。
本書全面闡釋了領域驅動設計（domain-driven design，DDD）的知識體系，內容覆蓋領域驅動設計的主要模式與主流方法，並在此基礎上提出「領域驅動設計統一過程」（domain-driven design unified process，DDDUP），將整個軟體構建過程劃分為全局分析、架構映射和領域建模3個階段。除給出諸多案例來闡釋領域驅動設計統一過程中的方法與模式之外，本書還通過一個真實而完整的案例全面展現了如何進行領域驅動設計統一過程的實施和落地。為了更好地運用領域驅動設計統一過程，本書還開創性地引入了業務服務、菱形對稱架構、領域驅動架構、服務驅動設計等方法與模式，總結了領域驅動設計能力評估模型與參考過程模型。本書提出的一整套方法體系已在多個項目中推廣和落地。
劉遄 著
Linux入門教程書籍，基於Linux系統RHEL8編寫，每章帶有圖表及習題，知識點覆蓋紅帽認證RHCE考試要求。
1.本書耗時近3年時間，修訂1500餘次，內容源自國內每天訪問量近60000人次的同名Linux培訓課程;
2.在上一版的基礎上進行了系統的更新，基於Linux系統RHEL 8編寫，適用於CentOS、Fedora、Ubuntu等主流衍生版本;
3.面向零基礎讀者，從Linux基礎知識講起，漸進式地提高內容難度。
《Linux就該這么學（第2版）》在上一版的基礎上進行了大量的更新，基於紅帽RHEL 8系統編寫，且內容適用於CentOS、Fedora等系統。本書共分為20章，內容涵蓋了部署Linux系統，常用的Linux命令，與文件讀寫操作有關的技術，使用Vim編輯器編寫和修改配置文件，用戶身份與文件許可權的設置，硬碟設備分區、格式化以及掛載等操作，部署RAID磁碟陣列和LVM，firewalld防火牆與iptables防火牆的區別和配置，使用ssh服務管理遠程主機，使用Apache服務部署靜態網站，使用vsftpd服務傳輸文件，使用Samba或NFS實現文件共享，使用BIND提供域名解析服務，使用DHCP動態管理主機地址，使用Postfix與Dovecot部署郵件系統，使用Ansible服務實現自動化運維，使用iSCSI服務部署網路存儲，使用MariaDB資料庫管理系統，使用PXE+Kickstart無人值守安裝服務，使用LNMP架構部署動態網站環境等。此外，本書的配套站點還深度點評了紅帽RHCSA、RHCE、RHCA認證，方便讀者備考。
張鑫旭 著
CSS3.0入門到進階教程，前端博客"鑫空間-鑫生活"博主十年經驗沉澱之作，大量實戰案例且具有在線Demo演示，配套官方網站，隨時與作者溝通學習。
本書是「CSS世界三部曲」的最後一部。這是一本關於CSS的進階讀物，專門講CSS3及其之後版本的新特性。在本書中，作者結合自己多年的從業經驗，講解CSS基礎知識，並充分考慮前端開發者的需求，以CSS新特性的 歷史 背景為線索，去粗取精，注重細節，深入淺出地介紹了上百個CSS新特性。此外，作者專門還為本書開發了配套網站，用於書中實例效果的在線展示和問題答疑。
本書的所有內容都是作者經過深入思考和 探索 後提煉出來的，知識點多且內容豐富，注重技術細節、經驗分享和解決問題的思路。本書的主要目標是幫助前端開發者突破CSS技能提升的瓶頸，非常適合具有一定CSS基礎的前端開發者閱讀。
[美] 威廉·肖特斯（William Shotts） 著，門佳，李偉 譯
手把手教你學Linux操作系統，腳本shell編程代碼書寫，系統管理編程運維，學習使用bash（LinuxShell）編寫完整的程序。
本書對Linux命令行進行詳細的介紹，全書內容包括4個部分，第一部分由Shell的介紹開啟命令行基礎知識的學習之旅；第二部分講述配置文件的編輯，如何通過命令行控制計算機；第三部分探討常見的任務與必備工具；第四部分全面介紹Shell編程，讀者可通過動手編寫Shell腳本掌握Linux命令的應用，從而實現常見計算任務的自動化。通過閱讀本書，讀者將對Linux命令有更加深入的理解，並且可以將其應用到實際的工作中。
本書適合Linux初學人員、Linux系統管理人員及Linux愛好者閱讀。
[美] 布萊恩·W.克尼漢（Brian，W.，Kernighan） 著，韓磊 譯
UNIX的誕生記與發展史，計算機先驅布萊恩·W.克尼漢繼C程序設計語言後又一力作，講述貝爾實驗室的幕後故事，C/C++等重要發明的起源，探尋計算科學之光！
自1969年在貝爾實驗室的閣樓上誕生以來，Unix操作系統的發展遠遠超出其創造者們的想像。它帶動了許多創新軟體的開發，影響了無數程序員，改變了整個計算機技術的發展軌跡。
本書不但書寫Unix的 歷史 ，而且記錄作者的回憶，一探Unix的起源，試圖解釋什麼是Unix，Unix是如何產生的，以及Unix為何如此重要。除此之外，本書以輕松的口吻講述了一群在貝爾實驗室工作的發明天才的有趣往事，本書中每一個故事都是鮮為人知卻又值得傳播的寶貴資源。
本書適合對計算機或相關 歷史 感興趣的人閱讀。讀者不需要有太多的專業技術背景，就可以欣賞Unix背後的思想，了解它的重要性。
[印] 拉胡爾·沙瑪（Rahul Sharma）[芬]韋薩·凱拉維塔 著，鄧世超 譯
Rust系統編程指南自學教程書籍，學習Rust編程語言基礎，掌握更高端的編程範式，成就高段位的編程極客。
本書內容共17章，由淺入深地講解Rust相關的知識，涉及基礎語法、軟體包管理器、測試工具、類型系統、內存管理、異常處理、高級類型、並發模型、宏、外部函數介面、網路編程、HTTP、資料庫、WebAssembly、GTK+框架和GDB調試等重要知識點。
本書適合想學習Rust編程的讀者閱讀，希望讀者能夠對C、C++或者Python有一些了解。書中豐富的代碼示例和詳細的講解能夠幫助讀者快速上手，高效率掌握Rust編程。
B. 急需C++實現的Apriori演算法代碼
用C++ 實現的 可以 到http://download.csdn.net/down/188143/chanjuanzz下載 不過要注冊扣積分的
演算法實現
（一）核心類
Apriori演算法的核心實現類為AprioriAlgorithm，實現的Java代碼如下所示：
package org.shirdrn.datamining.association;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* <B>關聯規則挖掘：Apriori演算法</B>
*
* <P>該演算法基本上按照Apriori演算法的基本思想來實現的。
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class AprioriAlgorithm {
private Map<Integer, Set<String>> txDatabase; // 事務資料庫
private Float minSup; // 最小支持度
private Float minConf; // 最小置信度
private Integer txDatabaseCount; // 事務資料庫中的事務數
private Map<Integer, Set<Set<String>>> freqItemSet; // 頻繁項集集合
private Map<Set<String>, Set<Set<String>>> assiciationRules; // 頻繁關聯規則集合
public AprioriAlgorithm(
Map<Integer, Set<String>> txDatabase,
Float minSup,
Float minConf) {
this.txDatabase = txDatabase;
this.minSup = minSup;
this.minConf = minConf;
this.txDatabaseCount = this.txDatabase.size();
freqItemSet = new TreeMap<Integer, Set<Set<String>>>();
assiciationRules = new HashMap<Set<String>, Set<Set<String>>>();
}
/**
* 掃描事務資料庫，計算頻繁1-項集
* @return
*/
public Map<Set<String>, Float> getFreq1ItemSet() {
Map<Set<String>, Float> freq1ItemSetMap = new HashMap<Set<String>, Float>();
Map<Set<String>, Integer> candFreq1ItemSet = this.getCandFreq1ItemSet();
Iterator<Map.Entry<Set<String>, Integer>> it = candFreq1ItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Set<String>, Integer> entry = it.next();
// 計算支持度
Float supported = new Float(entry.getValue().toString())/new Float(txDatabaseCount);
if(supported>=minSup) {
freq1ItemSetMap.put(entry.getKey(), supported);
}
}
return freq1ItemSetMap;
}
/**
* 計算候選頻繁1-項集
* @return
*/
public Map<Set<String>, Integer> getCandFreq1ItemSet() {
Map<Set<String>, Integer> candFreq1ItemSetMap = new HashMap<Set<String>, Integer>();
Iterator<Map.Entry<Integer, Set<String>>> it = txDatabase.entrySet().iterator();
// 統計支持數，生成候選頻繁1-項集
while(it.hasNext()) {
Map.Entry<Integer, Set<String>> entry = it.next();
Set<String> itemSet = entry.getValue();
for(String item : itemSet) {
Set<String> key = new HashSet<String>();
key.add(item.trim());
if(!candFreq1ItemSetMap.containsKey(key)) {
Integer value = 1;
candFreq1ItemSetMap.put(key, value);
}
else {
Integer value = 1+candFreq1ItemSetMap.get(key);
candFreq1ItemSetMap.put(key, value);
}
}
}
return candFreq1ItemSetMap;
}
/**
* 根據頻繁(k-1)-項集計算候選頻繁k-項集
*
* @param m 其中m=k-1
* @param freqMItemSet 頻繁(k-1)-項集
* @return
*/
public Set<Set<String>> aprioriGen(int m, Set<Set<String>> freqMItemSet) {
Set<Set<String>> candFreqKItemSet = new HashSet<Set<String>>();
Iterator<Set<String>> it = freqMItemSet.iterator();
Set<String> originalItemSet = null;
while(it.hasNext()) {
originalItemSet = it.next();
Iterator<Set<String>> itr = this.getIterator(originalItemSet, freqMItemSet);
while(itr.hasNext()) {
Set<String> identicalSet = new HashSet<String>(); // 兩個項集相同元素的集合(集合的交運算)
identicalSet.addAll(originalItemSet);
Set<String> set = itr.next();
identicalSet.retainAll(set); // identicalSet中剩下的元素是identicalSet與set集合中公有的元素
if(identicalSet.size() == m-1) { // (k-1)-項集中k-2個相同
Set<String> differentSet = new HashSet<String>(); // 兩個項集不同元素的集合(集合的差運算)
differentSet.addAll(originalItemSet);
differentSet.removeAll(set); // 因為有k-2個相同，則differentSet中一定剩下一個元素，即differentSet大小為1
differentSet.addAll(set); // 構造候選k-項集的一個元素(set大小為k-1,differentSet大小為k)
candFreqKItemSet.add(differentSet); // 加入候選k-項集集合
}
}
}
return candFreqKItemSet;
}
/**
* 根據一個頻繁k-項集的元素(集合)，獲取到頻繁k-項集的從該元素開始的迭代器實例
* @param itemSet
* @param freqKItemSet 頻繁k-項集
* @return
*/
private Iterator<Set<String>> getIterator(Set<String> itemSet, Set<Set<String>> freqKItemSet) {
Iterator<Set<String>> it = freqKItemSet.iterator();
while(it.hasNext()) {
if(itemSet.equals(it.next())) {
break;
}
}
return it;
}
/**
* 根據頻繁(k-1)-項集，調用aprioriGen方法，計算頻繁k-項集
*
* @param k
* @param freqMItemSet 頻繁(k-1)-項集
* @return
*/
public Map<Set<String>, Float> getFreqKItemSet(int k, Set<Set<String>> freqMItemSet) {
Map<Set<String>, Integer> candFreqKItemSetMap = new HashMap<Set<String>, Integer>();
// 調用aprioriGen方法，得到候選頻繁k-項集
Set<Set<String>> candFreqKItemSet = this.aprioriGen(k-1, freqMItemSet);
// 掃描事務資料庫
Iterator<Map.Entry<Integer, Set<String>>> it = txDatabase.entrySet().iterator();
// 統計支持數
while(it.hasNext()) {
Map.Entry<Integer, Set<String>> entry = it.next();
Iterator<Set<String>> kit = candFreqKItemSet.iterator();
while(kit.hasNext()) {
Set<String> kSet = kit.next();
Set<String> set = new HashSet<String>();
set.addAll(kSet);
set.removeAll(entry.getValue()); // 候選頻繁k-項集與事務資料庫中元素做差元算
if(set.isEmpty()) { // 如果拷貝set為空，支持數加1
if(candFreqKItemSetMap.get(kSet) == null) {
Integer value = 1;
candFreqKItemSetMap.put(kSet, value);
}
else {
Integer value = 1+candFreqKItemSetMap.get(kSet);
candFreqKItemSetMap.put(kSet, value);
}
}
}
}
// 計算支持度，生成頻繁k-項集，並返回
return support(candFreqKItemSetMap);
}
/**
* 根據候選頻繁k-項集，得到頻繁k-項集
*
* @param candFreqKItemSetMap 候選k項集(包含支持計數)
*/
public Map<Set<String>, Float> support(Map<Set<String>, Integer> candFreqKItemSetMap) {
Map<Set<String>, Float> freqKItemSetMap = new HashMap<Set<String>, Float>();
Iterator<Map.Entry<Set<String>, Integer>> it = candFreqKItemSetMap.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Set<String>, Integer> entry = it.next();
// 計算支持度
Float supportRate = new Float(entry.getValue().toString())/new Float(txDatabaseCount);
if(supportRate<minSup) { // 如果不滿足最小支持度，刪除
it.remove();
}
else {
freqKItemSetMap.put(entry.getKey(), supportRate);
}
}
return freqKItemSetMap;
}
/**
* 挖掘全部頻繁項集
*/
public void mineFreqItemSet() {
// 計算頻繁1-項集
Set<Set<String>> freqKItemSet = this.getFreq1ItemSet().keySet();
freqItemSet.put(1, freqKItemSet);
// 計算頻繁k-項集(k>1)
int k = 2;
while(true) {
Map<Set<String>, Float> freqKItemSetMap = this.getFreqKItemSet(k, freqKItemSet);
if(!freqKItemSetMap.isEmpty()) {
this.freqItemSet.put(k, freqKItemSetMap.keySet());
freqKItemSet = freqKItemSetMap.keySet();
}
else {
break;
}
k++;
}
}
/**
* <P>挖掘頻繁關聯規則
* <P>首先挖掘出全部的頻繁項集，在此基礎上挖掘頻繁關聯規則
*/
public void mineAssociationRules() {
freqItemSet.remove(1); // 刪除頻繁1-項集
Iterator<Map.Entry<Integer, Set<Set<String>>>> it = freqItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Integer, Set<Set<String>>> entry = it.next();
for(Set<String> itemSet : entry.getValue()) {
// 對每個頻繁項集進行關聯規則的挖掘
mine(itemSet);
}
}
}
/**
* 對從頻繁項集集合freqItemSet中每迭代出一個頻繁項集元素，執行一次關聯規則的挖掘
* @param itemSet 頻繁項集集合freqItemSet中的一個頻繁項集元素
*/
public void mine(Set<String> itemSet) {
int n = itemSet.size()/2; // 根據集合的對稱性，只需要得到一半的真子集
for(int i=1; i<=n; i++) {
// 得到頻繁項集元素itemSet的作為條件的真子集集合
Set<Set<String>> properSubset = ProperSubsetCombination.getProperSubset(i, itemSet);
// 對條件的真子集集合中的每個條件項集，獲取到對應的結論項集，從而進一步挖掘頻繁關聯規則
for(Set<String> conditionSet : properSubset) {
Set<String> conclusionSet = new HashSet<String>();
conclusionSet.addAll(itemSet);
conclusionSet.removeAll(conditionSet); // 刪除條件中存在的頻繁項
confide(conditionSet, conclusionSet); // 調用計算置信度的方法，並且挖掘出頻繁關聯規則
}
}
}
/**
* 對得到的一個條件項集和對應的結論項集，計算該關聯規則的支持計數，從而根據置信度判斷是否是頻繁關聯規則
* @param conditionSet 條件頻繁項集
* @param conclusionSet 結論頻繁項集
*/
public void confide(Set<String> conditionSet, Set<String> conclusionSet) {
// 掃描事務資料庫
Iterator<Map.Entry<Integer, Set<String>>> it = txDatabase.entrySet().iterator();
// 統計關聯規則支持計數
int conditionToConclusionCnt = 0; // 關聯規則(條件項集推出結論項集)計數
int conclusionToConditionCnt = 0; // 關聯規則(結論項集推出條件項集)計數
int supCnt = 0; // 關聯規則支持計數
while(it.hasNext()) {
Map.Entry<Integer, Set<String>> entry = it.next();
Set<String> txSet = entry.getValue();
Set<String> set1 = new HashSet<String>();
Set<String> set2 = new HashSet<String>();
set1.addAll(conditionSet);
set1.removeAll(txSet); // 集合差運算：set-txSet
if(set1.isEmpty()) { // 如果set為空，說明事務資料庫中包含條件頻繁項conditionSet
// 計數
conditionToConclusionCnt++;
}
set2.addAll(conclusionSet);
set2.removeAll(txSet); // 集合差運算：set-txSet
if(set2.isEmpty()) { // 如果set為空，說明事務資料庫中包含結論頻繁項conclusionSet
// 計數
conclusionToConditionCnt++;
}
if(set1.isEmpty() && set2.isEmpty()) {
supCnt++;
}
}
// 計算置信度
Float conditionToConclusionConf = new Float(supCnt)/new Float(conditionToConclusionCnt);
if(conditionToConclusionConf>=minConf) {
if(assiciationRules.get(conditionSet) == null) { // 如果不存在以該條件頻繁項集為條件的關聯規則
Set<Set<String>> conclusionSetSet = new HashSet<Set<String>>();
conclusionSetSet.add(conclusionSet);
assiciationRules.put(conditionSet, conclusionSetSet);
}
else {
assiciationRules.get(conditionSet).add(conclusionSet);
}
}
Float conclusionToConditionConf = new Float(supCnt)/new Float(conclusionToConditionCnt);
if(conclusionToConditionConf>=minConf) {
if(assiciationRules.get(conclusionSet) == null) { // 如果不存在以該結論頻繁項集為條件的關聯規則
Set<Set<String>> conclusionSetSet = new HashSet<Set<String>>();
conclusionSetSet.add(conditionSet);
assiciationRules.put(conclusionSet, conclusionSetSet);
}
else {
assiciationRules.get(conclusionSet).add(conditionSet);
}
}
}
/**
* 經過挖掘得到的頻繁項集Map
*
* @return 挖掘得到的頻繁項集集合
*/
public Map<Integer, Set<Set<String>>> getFreqItemSet() {
return freqItemSet;
}
/**
* 獲取挖掘到的全部的頻繁關聯規則的集合
* @return 頻繁關聯規則集合
*/
public Map<Set<String>, Set<Set<String>>> getAssiciationRules() {
return assiciationRules;
}
}
（二）輔助類
ProperSubsetCombination類是一個輔助類，在挖掘頻繁關聯規則的過程中，用於生成一個頻繁項集元素的非空真子集，實現代碼如下：
package org.shirdrn.datamining.association;
import java.util.BitSet;
import java.util.HashSet;
import java.util.Set;
/**
* <B>求頻繁項集元素(集合)的非空真子集集合</B>
* <P>從一個集合（大小為n）中取出m(m屬於2~n/2的閉區間)個元素的組合實現類，獲取非空真子集的集合
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class ProperSubsetCombination {
private static String[] array;
private static BitSet startBitSet; // 比特集合起始狀態
private static BitSet endBitSet; // 比特集合終止狀態，用來控制循環
private static Set<Set<String>> properSubset; // 真子集集合
/**
* 計算得到一個集合的非空真子集集合
*
* @param n 真子集的大小
* @param itemSet 一個頻繁項集元素
* @return 非空真子集集合
*/
public static Set<Set<String>> getProperSubset(int n, Set<String> itemSet) {
String[] array = new String[itemSet.size()];
ProperSubsetCombination.array = itemSet.toArray(array);
properSubset = new HashSet<Set<String>>();
startBitSet = new BitSet();
endBitSet = new BitSet();
// 初始化startBitSet，左側占滿1
for (int i=0; i<n; i++) {
startBitSet.set(i, true);
}
// 初始化endBit，右側占滿1
for (int i=array.length-1; i>=array.length-n; i--) {
endBitSet.set(i, true);
}
// 根據起始startBitSet，將一個組合加入到真子集集合中
get(startBitSet);
while(!startBitSet.equals(endBitSet)) {
int zeroCount = 0; // 統計遇到10後，左邊0的個數
int oneCount = 0; // 統計遇到10後，左邊1的個數
int pos = 0; // 記錄當前遇到10的索引位置
// 遍歷startBitSet來確定10出現的位置
for (int i=0; i<array.length; i++) {
if (!startBitSet.get(i)) {
zeroCount++;
}
if (startBitSet.get(i) && !startBitSet.get(i+1)) {
pos = i;
oneCount = i - zeroCount;
// 將10變為01
startBitSet.set(i, false);
startBitSet.set(i+1, true);
break;
}
}
// 將遇到10後，左側的1全部移動到最左側
int counter = Math.min(zeroCount, oneCount);
int startIndex = 0;
int endIndex = 0;
if(pos>1 && counter>0) {
pos--;
endIndex = pos;
for (int i=0; i<counter; i++) {
startBitSet.set(startIndex, true);
startBitSet.set(endIndex, false);
startIndex = i+1;
pos--;
if(pos>0) {
endIndex = pos;
}
}
}
get(startBitSet);
}
return properSubset;
}
/**
* 根據一次移位操作得到的startBitSet，得到一個真子集
* @param bitSet
*/
private static void get(BitSet bitSet) {
Set<String> set = new HashSet<String>();
for(int i=0; i<array.length; i++) {
if(bitSet.get(i)) {
set.add(array[i]);
}
}
properSubset.add(set);
}
}
測試用例
對上述Apriori演算法的實現進行了簡單的測試，測試用例如下所示：
package org.shirdrn.datamining.association;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.shirdrn.datamining.association.AprioriAlgorithm;
import junit.framework.TestCase;
/**
* <B>Apriori演算法測試類</B>
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class TestAprioriAlgorithm extends TestCase {
private AprioriAlgorithm apriori;
private Map<Integer, Set<String>> txDatabase;
private Float minSup = new Float("0.50");
private Float minConf = new Float("0.70");
@Override
protected void setUp() throws Exception {
create(); // 構造事務資料庫
apriori = new AprioriAlgorithm(txDatabase, minSup, minConf);
}
/**
* 構造模擬事務資料庫txDatabase
*/
public void create() {
txDatabase = new HashMap<Integer, Set<String>>();
Set<String> set1 = new TreeSet<String>();
set1.add("A");
set1.add("B");
set1.add("C");
set1.add("E");
txDatabase.put(1, set1);
Set<String> set2 = new TreeSet<String>();
set2.add("A");
set2.add("B");
set2.add("C");
txDatabase.put(2, set2);
Set<String> set3 = new TreeSet<String>();
set3.add("C");
set3.add("D");
txDatabase.put(3, set3);
Set<String> set4 = new TreeSet<String>();
set4.add("A");
set4.add("B");
set4.add("E");
txDatabase.put(4, set4);
}
/**
* 測試挖掘頻繁1-項集
*/
public void testFreq1ItemSet() {
System.out.println("挖掘頻繁1-項集 : " + apriori.getFreq1ItemSet());
}
/**
* 測試aprioriGen方法，生成候選頻繁項集
*/
public void testAprioriGen() {
System.out.println(
"候選頻繁2-項集 ： " +
this.apriori.aprioriGen(1, this.apriori.getFreq1ItemSet().keySet())
);
}
/**
* 測試挖掘頻繁2-項集
*/
public void testGetFreq2ItemSet() {
System.out.println(
"挖掘頻繁2-項集 ：" +
this.apriori.getFreqKItemSet(2, this.apriori.getFreq1ItemSet().keySet())
);
}
/**
* 測試挖掘頻繁3-項集
*/
public void testGetFreq3ItemSet() {
System.out.println(
"挖掘頻繁3-項集 ：" +
this.apriori.getFreqKItemSet(
3,
this.apriori.getFreqKItemSet(2, this.apriori.getFreq1ItemSet().keySet()).keySet()
)
);
}
/**
* 測試挖掘全部頻繁項集
*/
public void testGetFreqItemSet() {
this.apriori.mineFreqItemSet(); // 挖掘頻繁項集
System.out.println("挖掘頻繁項集 ：" + this.apriori.getFreqItemSet());
}
/**
* 測試挖掘全部頻繁關聯規則
*/
public void testMineAssociationRules() {
this.apriori.mineFreqItemSet(); // 挖掘頻繁項集
this.apriori.mineAssociationRules();
System.out.println("挖掘頻繁關聯規則 ：" + this.apriori.getAssiciationRules());
}
}
測試結果：
挖掘頻繁1-項集 : {[E]=0.5, [A]=0.75, [B]=0.75, [C]=0.75}
候選頻繁2-項集 ： [[E, C], [A, B], [B, C], [A, C], [E, B], [E, A]]
挖掘頻繁2-項集 ：{[A, B]=0.75, [B, C]=0.5, [A, C]=0.5, [E, B]=0.5, [E, A]=0.5}
挖掘頻繁3-項集 ：{[E, A, B]=0.5, [A, B, C]=0.5}
挖掘頻繁項集 ：{1=[[E], [A], [B], [C]], 2=[[A, B], [B, C], [A, C], [E, B], [E, A]], 3=[[E, A, B], [A, B, C]]}
挖掘頻繁關聯規則 ：{[E]=[[A], [B], [A, B]], [A]=[[B]], [B]=[[A]], [B, C]=[[A]], [A, C]=[[B]], [E, B]=[[A]], [E, A]=[[B]]}
從測試結果看到，使用Apriori演算法挖掘得到的全部頻繁項集為：
{1=[[E], [A], [B], [C]], 2=[[A, B], [B, C], [A, C], [E, B], [E, A]], 3=[[E, A, B], [A, B, C]]}
使用Apriori演算法挖掘得到的全部頻繁關聯規則為：
{E}→{A}、{E}→{B}、{E}→{A,B}、{A}→{B}、{B}→{A}、{B,C}→{A}、{A,C}→{B}、{B,E}→{A}、{A,E}→{B}。
C. Java編程實現字元串的模式匹配
傳統的字元串模式匹配演算法（也就是BF演算法）就是對於主串和模式串雙雙自左向右，一個一個字元比較，如果不匹配，主串和模式串的位置指針都要回溯。這樣的演算法時間復雜度為O（n＊m），其中n和m分別為串s和串t的長度。
KMP 演算法是由Knuth，Morris和Pratt等人共同提出的，所以成為Knuth－Morris－Pratt演算法，簡稱KMP演算法。KMP演算法是字元串模式匹配中的經典演算法。和BF演算法相比，KMP演算法的不同點是匹配過程中，主串的位置指針不會回溯，這樣的結果使得演算法時間復雜度只為O（n＋m）。
D. 數獨設計思路及全解
開始的話：這個程序現在還不穩定，有時出現運行時錯誤，跟蹤是由於vector的size()方法引起的。調試發現中間的min_seq並沒有完全按照作者的意圖變化。
運行時，如果出現錯誤，就反復運行，運行成功即可出現一個正確的9*9數獨矩陣。
如果要玩預先填充一些數的游戲，只需修改初始矩陣即可。
演算法：為每個位置定義一個可選元素集合，每個更新是把它所在的行，列,所在的3×3方陣中已出現的元素從集合中去掉。填充時，從最小候選集合中選一個(可隨即)填進去，更新候選集合，再填充，直到所有位置填充完畢，游戲結束。
/*******9×9數獨游戲的計算機程序*******/
/*******作者：xiaocui******************/
/*******時間：2006.6.23****************/
/*******版本：v1.0*********************/
/*******演算法思想***********************/
/******對每個位置的元素，考慮其可選取的數字
的集合，每次把候選元素個數最小的那個位置填充
從該最小候選集合中隨機選取一個元素填充，重復
這個過程，直到所有元素填充完畢************/
/****適用填充全空的數獨方格 和 填充已有一些數的數獨方格*****/
/****對初始化的候選集的第一次更新正是為了解決第2類數獨游戲***/
/****對於已填充一部分元素的，直接修改MATRIX矩陣即可*****/
/****數獨游戲的結果不止一種********/
#include <iostream>
#include <ctime>
#include <vector>
using namespace std;
/**********初始9×9的矩陣*************/
/******元素為0，說明該位置還未填充***/
int MATRIX[9][9]={ {0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0} };
/*******初始給出的元素個數***********/
int INITIAL_COUNT;
/********已填充元素個數，作為填充結束標志**********/
int FINISH_COUNT=0;
/********各個元素的初始候選集合*******/
vector<vector<int> > IVEC(81);
/**************函數原型******************/
/*********得到初始給出的元素個數*******/
int get_initialcount();
/*******初始化候選集合***************/
void initial_candidate();
/***********從vector中刪除指定元素*******/
void delete_value(vector<int> &ivec,int value);
/********更新候選集合**************/
void refresh_candidate();
/*********返回9×9候選集合元素最少的候選集合序號*******/
int min_seq();
/********隨機生成一個位置序號並取得該序號所對應的元素值******/
int choose_seq(int min_seq);
/*******填充該元素並判斷是否填充完畢********/
int is_finish(int min_seq, int choose_value);
int main()
{
/******得到初始給出的元素個數*****/
INITIAL_COUNT=get_initialcount();
/******初始化候選集合*******/
initial_candidate();
/********先更新候選集合(為了應付已經填充一部分數的情況)******/
refresh_candidate();
int i;
int MinSeq;
int ChooseValue;
MinSeq=min_seq();
ChooseValue=choose_seq(MinSeq);
while(is_finish(MinSeq,ChooseValue)!=1)
{
refresh_candidate();
MinSeq=min_seq();
ChooseValue=choose_seq(MinSeq);
}
/**********輸出填好的數獨游戲結果*********/
for( i=0;i<9;++i)
{
for(int j=0;j<9;++j)
{
cout<<MATRIX[i][j]<<'\t';
}
cout<<endl;
}
return 0;
}
/*******************函數定義***********************/
/*********得到初始給出的元素個數*******/
int get_initialcount()
{
int count=0;
for(int i=0;i<9;++i)
{
for(int j=0;j<9;++j)
{
if(MATRIX[i][j]!=0)
{
count++;
}
}
}
return count;
}
/*******初始化候選集合***************/
void initial_candidate()
{
for(int i=0;i<81;++i)
{
for(int j=1;j<10;++j)
{
IVEC[i].push_back(j);
}
}
}
/***********從vector中刪除指定元素*******/
void delete_value(vector<int> &ivec,int value)
{
/*******如果ivec已經為空，直接退出**********/
if (ivec.size()==0)
{
return;
}
vector<int>::iterator iter=ivec.begin();
while( iter<ivec.end() && (*iter)!=value )
{
iter++;
}
if(iter<ivec.end())//在vector中找到已填充的元素，把它刪除
{
ivec.erase(iter);
}
}
/********更新候選集合**************/
void refresh_candidate()
{
int i;
int rownum,colnum;
int row,col;
/******更新81個vector*******/
for(i=0;i<81;++i)
{
row=i/9;
col=i%9;
if(MATRIX[row][col]!=0)//該位置已經填充
{
if(IVEC[i].size()!=0)//該vector不空
{
/********刪除整個候選集***********/
IVEC[i].erase(IVEC[i].begin(),IVEC[i].end());
}
}
else
{
/*****刪除同一行中的元素****/
for(colnum=0;colnum<9;++colnum)
{
delete_value(IVEC[i],MATRIX[row][colnum]);
}
/*****刪除同一列中的元素****/
for(rownum=0;rownum<9;++rownum)
{
delete_value(IVEC[i],MATRIX[rownum][col]);
}
/*****刪除在一個3×3方陣中的元素******/
/******在第1塊中，刪除3×3方陣元素*****/
if(row/3==0 && col/3==0)
{
for(int r=0;r<3;++r)
{
for(int c=0;c<3;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第2塊中，刪除3×3方陣元素*****/
if(row/3==0 && col/3==1)
{
for(int r=0;r<3;++r)
{
for(int c=3;c<6;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第3塊中，刪除3×3方陣元素*****/
if(row/3==0 && col/3==2)
{
for(int r=0;r<3;++r)
{
for(int c=6;c<9;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第4塊中，刪除3×3方陣元素*****/
if(row/3==1 && col/3==0)
{
for(int r=3;r<6;++r)
{
for(int c=0;c<3;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第5塊中，刪除3×3方陣元素*****/
if(row/3==1 && col/3==1)
{
for(int r=3;r<6;++r)
{
for(int c=3;c<6;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第6塊中，刪除3×3方陣元素*****/
if(row/3==1 && col/3==2)
{
for(int r=3;r<6;++r)
{
for(int c=6;c<9;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第7塊中，刪除3×3方陣元素*****/
if(row/3==2 && col/3==0)
{
for(int r=6;r<9;++r)
{
for(int c=0;c<3;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第8塊中，刪除3×3方陣元素*****/
if(row/3==2 && col/3==1)
{
for(int r=6;r<9;++r)
{
for(int c=3;c<6;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
/******在第9塊中，刪除3×3方陣元素*****/
if(row/3==2 && col/3==2)
{
for(int r=6;r<9;++r)
{
for(int c=6;c<9;++c)
{
delete_value(IVEC[i],MATRIX[r][c]);
}
}
}
}
}
}
/*********返回9×9候選集合元素最少的候選集合序號*******/
int min_seq()
{
int count[81];
int i;
for(i=0;i<81;++i)
{
count[i]=IVEC[i].size();
}
int value=10;
int min_seq;
for(i=0;i<81;++i)
{
if(count[i]==0)
{
continue;
}
if(count[i]<value)
{
value=count[i];
min_seq=i;
}
}
return min_seq;
}
/********隨機生成一個位置序號並取得該序號所對應的元素值******/
int choose_seq(int min_seq)
{
/*****根據當前時間設置種子******/
srand((unsigned)time( NULL ));
int random_seq=rand()%(IVEC[min_seq].size());
return IVEC[min_seq][random_seq];
}
/*******填充該元素並判斷是否填充完畢********/
int is_finish(int min_seq, int choose_value)
{
int row, column;
row=min_seq/9;
column=min_seq%9;
MATRIX[row][column]=choose_value;
FINISH_COUNT++; /****已填充元素個數加1*****/
/*******填充完畢判斷********/
if(FINISH_COUNT==81-INITIAL_COUNT)
{
return 1;
}
else
{
return 0;
}
}
http://den.idv.tw/den/java/sudo/makeprob.php
http://hi..com/cuifenghui/blog/item/f771396dd111bbfb421694ee.html
希望對你有幫助！！
E. java代碼怎麼獲取數字的證書那一串20位指紋
通過JAVA來讀取數字證書的方法獲取20位指紋：
CARead.java文件代碼：
public class CARead extends JPanel {
private String CA_Name;
private String CA_ItemData[][] = new String[9][2];
private String[] columnNames = { "證書欄位標記", "內容" };
public CARead(String CertName) {
CA_Name = CertName;
/* 三個Panel用來顯示證書內容 */
JTabbedPane tabbedPane = new JTabbedPane();
JPanel panelNormal = new JPanel();
tabbedPane.addTab("普通信息", panelNormal);
JPanel panelAll = new JPanel();
panelAll.setLayout(new BorderLayout());
tabbedPane.addTab("所有信息", panelAll);
JPanel panelBase64 = new JPanel();
panelBase64.setLayout(new BorderLayout());
tabbedPane.addTab("Base64編碼形式的信息", panelBase64);
/* 讀取證書常規信息 */
Read_Normal(panelNormal);
/* 讀取證書文件字元串表示內容 */
Read_Bin(panelAll);
/* 以Base64編碼形式讀取證書文件的信息 */
Read_Raw(panelBase64);
tabbedPane.setSelectedIndex(0);
setLayout(new GridLayout(1, 1));
add(tabbedPane);
}
private int Read_Normal(JPanel panel) {
String Field;
try {
CertificateFactory certificate_factory = CertificateFactory
.getInstance("X.509");
FileInputStream file_inputstream = new FileInputStream(CA_Name);
X509Certificate x509certificate = (X509Certificate) certificate_factory
.generateCertificate(file_inputstream);
Field = x509certificate.getType();
CA_ItemData[0][0] = "類型";
CA_ItemData[0][1] = Field;
Field = Integer.toString(x509certificate.getVersion());
CA_ItemData[1][0] = "版本";
CA_ItemData[1][1] = Field;
Field = x509certificate.getSubjectDN().getName();
CA_ItemData[2][0] = "標題";
CA_ItemData[2][1] = Field;
Field=x509certificate.getNotBefore().toString();//得到開始有效日期
CA_ItemData[3][0] = "開始有效日期";
CA_ItemData[3][1] = Field;
Field=x509certificate. getNotAfter().toString();//得到截止日期
CA_ItemData[4][0] = "截止日期";
CA_ItemData[4][1] = Field;
Field=x509certificate.getSerialNumber().toString(16);//得到序列號
CA_ItemData[5][0] = "序列號";
CA_ItemData[5][1] = Field;
Field=x509certificate.getIssuerDN().getName();//得到發行者名
CA_ItemData[6][0] = "發行者名";
CA_ItemData[6][1] = Field;
Field=x509certificate.getSigAlgName();//得到簽名演算法
CA_ItemData[7][0] = "簽名演算法";
CA_ItemData[7][1] = Field;
Field=x509certificate.getPublicKey().getAlgorithm();//得到公鑰演算法
CA_ItemData[8][0] = "公鑰演算法";
CA_ItemData[8][1] = Field;
//關閉輸入流對象
file_inputstream.close();
final JTable table = new JTable(CA_ItemData, columnNames);
TableColumn tc = null; //表格列控制
tc = table.getColumnModel().getColumn(1);//得到表頭
tc.setPreferredWidth(600);//設置寬度
panel.add(table);//增加到布局面板
} catch (Exception exception) {
exception.printStackTrace(); //異常捕獲、
return -1;
}
return 0;
}
//讀取二進制指紋文件
private int Read_Bin(JPanel panel) {
try {
FileInputStream file_inputstream = new FileInputStream(CA_Name);
DataInputStream data_inputstream = new DataInputStream(
file_inputstream);
CertificateFactory certificatefactory = CertificateFactory
.getInstance("X.509");
byte[] bytes = new byte[data_inputstream.available()];
data_inputstream.readFully(bytes);
ByteArrayInputStream s = new ByteArrayInputStream(bytes);
JEditorPane Cert_EditorPane;
Cert_EditorPane = new JEditorPane();
X509Certificate cert=null;
//遍歷得到所有的證書屬性
if (s.available() > 0)
{
cert = (X509Certificate) certificatefactory .generateCertificate(s);
Cert_EditorPane.setText(cert.toString());
}
Cert_EditorPane.disable();
JScrollPane edit_scroll = new JScrollPane(Cert_EditorPane);
panel.add(edit_scroll);
file_inputstream.close();
data_inputstream.close();
} catch (Exception exception) {
exception.printStackTrace();
return -1;
}
return 0;
}
private int Read_Raw(JPanel panel) {
try {
JEditorPane Cert_EditorPane = new JEditorPane();
StringBuffer strBuffer =new StringBuffer();
File inputFile = new File(CA_Name);
FileReader in = new FileReader(inputFile);
char[] buf = new char[2000];
int len = in.read(buf, 0, 2000);
for (int i = 1; i < len; i++) {
strBuffer.append(buf[i]);
}
in.close();
Cert_EditorPane.setText(strBuffer.toString());
Cert_EditorPane.disable();
JScrollPane edit_scroll = new JScrollPane(Cert_EditorPane);
panel.add(edit_scroll);
} catch (Exception exception) {
exception.printStackTrace();
return -1;
}
return 0;
}
}
F. 常用數據校驗方法有哪些
奇偶校驗」。內存中最小的單位是比特，也稱為「位」，位有隻有兩種狀態分別以1和0來標示，每8個連續的比特叫做一個位元組（byte）。不帶奇偶校驗的內存每個位元組只有8位，如果其某一位存儲了錯誤的值，就會導致其存儲的相應數據發生變化，進而導致應用程序發生錯誤。而奇偶校驗就是在每一位元組（8位）之外又增加了一位作為錯誤檢測位。在某位元組中存儲數據之後，在其8個位上存儲的數據是固定的，因為位只能有兩種狀態1或0，假設存儲的數據用位標示為1、1、 1、0、0、1、0、1，那麼把每個位相加（1＋1＋1＋0＋0＋1＋0＋1＝5），結果是奇數，那麼在校驗位定義為1，反之為0。當CPU讀取存儲的數據時，它會再次把前8位中存儲的數據相加，計算結果是否與校驗位相一致。從而一定程度上能檢測出內存錯誤，奇偶校驗只能檢測出錯誤而無法對其進行修正，同時雖然雙位同時發生錯誤的概率相當低，但奇偶校驗卻無法檢測出雙位錯誤。
MD5的全稱是Message-Digest Algorithm 5，在90年代初由MIT的計算機科學實驗室和RSA Data Security Inc 發明，由 MD2/MD3/MD4 發展而來的。MD5的實際應用是對一段Message(位元組串)產生fingerprint(指紋)，可以防止被「篡改」。舉個例子，天天安全網提供下載的MD5校驗值軟體WinMD5.zip，其MD5值是，但你下載該軟體後計算MD5 發現其值卻是，那說明該ZIP已經被他人修改過，那還用不用該軟體那你可自己琢磨著看啦。
MD5廣泛用於加密和解密技術上，在很多操作系統中，用戶的密碼是以MD5值（或類似的其它演算法）的方式保存的，用戶Login的時候，系統是把用戶輸入的密碼計算成MD5值，然後再去和系統中保存的MD5值進行比較，來驗證該用戶的合法性。
MD5校驗值軟體WinMD5.zip漢化版，使用極其簡單，運行該軟體後，把需要計算MD5值的文件用滑鼠拖到正在處理的框里邊，下面將直接顯示其MD5值以及所測試的文件名稱，可以保留多個文件測試的MD5值，選定所需要復制的MD5值，用CTRL+C就可以復制到其它地方了。
參考資料：http://..com/question/3933661.html
CRC演算法原理及C語言實現 －來自（我愛單片機）
摘 要 本文從理論上推導出CRC演算法實現原理，給出三種分別適應不同計算機或微控制器硬體環境的C語言程序。讀者更能根據本演算法原理，用不同的語言編寫出獨特風格更加實用的CRC計算程序。
關鍵詞 CRC 演算法 C語言
1 引言
循環冗餘碼CRC檢驗技術廣泛應用於測控及通信領域。CRC計算可以靠專用的硬體來實現，但是對於低成本的微控制器系統，在沒有硬體支持下實現CRC檢驗，關鍵的問題就是如何通過軟體來完成CRC計算，也就是CRC演算法的問題。
這里將提供三種演算法，它們稍有不同，一種適用於程序空間十分苛刻但CRC計算速度要求不高的微控制器系統，另一種適用於程序空間較大且CRC計算速度要求較高的計算機或微控制器系統，最後一種是適用於程序空間不太大，且CRC計算速度又不可以太慢的微控制器系統。
2 CRC簡介
CRC 校驗的基本思想是利用線性編碼理論，在發送端根據要傳送的k位二進制碼序列，以一定的規則產生一個校驗用的監督碼（既CRC碼）r位，並附在信息後邊，構成一個新的二進制碼序列數共(k+r)位，最後發送出去。在接收端，則根據信息碼和CRC碼之間所遵循的規則進行檢驗，以確定傳送中是否出錯。
16位的CRC碼產生的規則是先將要發送的二進制序列數左移16位（既乘以 ）後，再除以一個多項式，最後所得到的余數既是CRC碼，如式（2-1）式所示，其中B(X)表示n位的二進制序列數，G(X)為多項式，Q(X)為整數，R(X)是余數（既CRC碼）。
（2-1）
求CRC 碼所採用模2加減運演算法則，既是不帶進位和借位的按位加減，這種加減運算實際上就是邏輯上的異或運算，加法和減法等價，乘法和除法運算與普通代數式的乘除法運算是一樣，符合同樣的規律。生成CRC碼的多項式如下，其中CRC-16和CRC-CCITT產生16位的CRC碼，而CRC-32則產生的是32位的CRC碼。本文不討論32位的CRC演算法，有興趣的朋友可以根據本文的思路自己去推導計算方法。
CRC-16：（美國二進制同步系統中採用）
CRC-CCITT：（由歐洲CCITT推薦）
CRC-32：
接收方將接收到的二進制序列數（包括信息碼和CRC碼）除以多項式，如果余數為0，則說明傳輸中無錯誤發生，否則說明傳輸有誤，關於其原理這里不再多述。用軟體計算CRC碼時，接收方可以將接收到的信息碼求CRC碼，比較結果和接收到的CRC碼是否相同。
3 按位計算CRC
對於一個二進制序列數可以表示為式(3-1):
(3-1)
求此二進制序列數的CRC碼時，先乘以 後（既左移16位），再除以多項式G(X)，所得的余數既是所要求的CRC碼。如式(3-2)所示：
(3-2)
可以設： (3-3)
其中 為整數， 為16位二進制余數。將式(3-3)代入式(3-2)得：
(3-4)
再設： (3-5)
其中 為整數， 為16位二進制余數，將式(3-5)代入式(3-4)，如上類推，最後得到：
(3-6)
根據CRC的定義，很顯然，十六位二進制數 既是我們要求的CRC碼。
式(3 -5)是編程計算CRC的關鍵，它說明計算本位後的CRC碼等於上一位CRC碼乘以2後除以多項式，所得的余數再加上本位值除以多項式所得的余數。由此不難理解下面求CRC碼的C語言程序。*ptr指向發送緩沖區的首位元組，len是要發送的總位元組數，0x1021與多項式有關。
[code]
unsigned int cal_crc(unsigned char *ptr, unsigned char len) {
unsigned char i;
unsigned int crc=0;
while(len--!=0) {
for(i=0x80; i!=0; i/=2) {
if((crc&0x8000)!=0) {crc*=2; crc^=0x1021;} /* 余式CRC乘以2再求CRC */
else crc*=2;
if((*ptr&i)!=0) crc^=0x1021; /* 再加上本位的CRC */
}
ptr++;
}
return(crc);
}
[code]
按位計算CRC雖然代碼簡單，所佔用的內存比較少，但其最大的缺點就是一位一位地計算會佔用很多的處理器處理時間，尤其在高速通訊的場合，這個缺點更是不可容忍。因此下面再介紹一種按位元組查錶快速計算CRC的方法。
4 按位元組計算CRC
不難理解，對於一個二進制序列數可以按位元組表示為式(4-1)，其中 為一個位元組(共8位)。
(4-1)
求此二進制序列數的CRC碼時，先乘以 後（既左移16位），再除以多項式G(X)，所得的余數既是所要求的CRC碼。如式(4-2)所示：
（4-2）
可以設： (4-3)
其中 為整數， 為16位二進制余數。將式(4-3)代入式(4-2)得：
（4-4）
因為：
（4-5）
其中 是 的高八位， 是 的低八位。將式（4-5）代入式（4-4），經整理後得：
（4-6）
再設： (4-7)
其中 為整數， 為16位二進制余數。將式(4-7)代入式(4-6)，如上類推，最後得：
(4-
很顯然，十六位二進制數 既是我們要求的CRC碼。
式(4 -7)是編寫按位元組計算CRC程序的關鍵，它說明計算本位元組後的CRC碼等於上一位元組余式CRC碼的低8位左移8位後，再加上上一位元組CRC右移8位（也既取高8位）和本位元組之和後所求得的CRC碼，如果我們把8位二進制序列數的CRC全部計算出來，放如一個表裡，採用查表法，可以大大提高計算速度。由此不難理解下面按位元組求CRC碼的C語言程序。*ptr指向發送緩沖區的首位元組，len是要發送的總位元組數，CRC余式表是按0x11021多項式求出的。
[code]
unsigned int cal_crc(unsigned char *ptr, unsigned char len) {
unsigned int crc;
unsigned char da;
unsigned int crc_ta[256]={ /* CRC余式表 */
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
0x 1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};
crc=0;
while(len--!=0) {
da=(uchar) (crc/256); /* 以8位二進制數的形式暫存CRC的高8位 */
crc<<=8; /* 左移8位，相當於CRC的低8位乘以 */
crc^=crc_ta[da^*ptr]; /* 高8位和當前位元組相加後再查表求CRC ，再加上以前的CRC */
ptr++;
}
return(crc);
}
很顯然，按位元組求CRC時，由於採用了查表法，大大提高了計算速度。但對於廣泛運用的8位微處理器，代碼空間有限，對於要求256個CRC余式表（共512位元組的內存）已經顯得捉襟見肘了，但CRC的計算速度又不可以太慢，因此再介紹下面一種按半位元組求CRC的演算法。
5 按半位元組計算CRC
同樣道理，對於一個二進制序列數可以按位元組表示為式(5-1)，其中 為半個位元組(共4位)。
(5-1)
求此二進制序列數的CRC碼時，先乘以 後（既左移16位），再除以多項式G(X)，所得的余數既是所要求的CRC碼。如式(4-2)所示：
（5-2）
可以設： (5-3)
其中 為整數， 為16位二進制余數。將式(5-3)代入式(5-2)得：
（5-4）
因為：
（5-5）
其中 是 的高4位， 是 的低12位。將式（5-5）代入式（5-4），經整理後得：
（5-6）
再設： (5-7)
其中 為整數， 為16位二進制余數。將式(5-7)代入式(5-6)，如上類推，最後得：
(5-
很顯然，十六位二進制數 既是我們要求的CRC碼。
式(5 -7)是編寫按位元組計算CRC程序的關鍵，它說明計算本位元組後的CRC碼等於上一位元組CRC碼的低12位左移4位後，再加上上一位元組余式CRC右移4位（也既取高4位）和本位元組之和後所求得的CRC碼，如果我們把4位二進制序列數的CRC全部計算出來，放在一個表裡，採用查表法，每個位元組算兩次（半位元組算一次），可以在速度和內存空間取得均衡。由此不難理解下面按半位元組求CRC碼的C語言程序。*ptr指向發送緩沖區的首位元組，len是要發送的總位元組數，CRC余式表是按0x11021多項式求出的。
unsigned cal_crc(unsigned char *ptr, unsigned char len) {
unsigned int crc;
unsigned char da;
unsigned int crc_ta[16]={ /* CRC余式表 */
0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
}
crc=0;
while(len--!=0) {
da=((uchar)(crc/256))/16; /* 暫存CRC的高四位 */
crc<<=4; /* CRC右移4位，相當於取CRC的低12位）*/
crc^=crc_ta[da^(*ptr/16)]; /* CRC的高4位和本位元組的前半位元組相加後查表計算CRC，
然後加上上一次CRC的余數 */
da=((uchar)(crc/256))/16; /* 暫存CRC的高4位 */
crc<<=4; /* CRC右移4位， 相當於CRC的低12位） */
crc^=crc_ta[da^(*ptr&0x0f)]; /* CRC的高4位和本位元組的後半位元組相加後查表計算CRC，
然後再加上上一次CRC的余數 */
ptr++;
}
return(crc);
}
[code]
5 結束語
以上介紹的三種求CRC的程序，按位求法速度較慢，但佔用最小的內存空間；按位元組查表求CRC的方法速度較快，但佔用較大的內存；按半位元組查表求CRC的方法是前兩者的均衡，即不會佔用太多的內存，同時速度又不至於太慢，比較適合8位小內存的單片機的應用場合。以上所給的C程序可以根據各微處理器編譯器的特點作相應的改變，比如把CRC余式表放到程序存儲區內等。[/code]
hjzgq 回復於：2003-05-15 14:12:51
CRC32演算法學習筆記以及如何用java實現 出自：csdn bootcool 2002年10月19日 23:11 CRC32演算法學習筆記以及如何用java實現
CRC32演算法學習筆記以及如何用java實現
一：說明
論壇上關於CRC32校驗演算法的詳細介紹不多。前幾天偶爾看到Ross N. Williams的文章，總算把CRC32演算法的來龍去脈搞清楚了。本來想把原文翻譯出來，但是時間參促，只好把自己的一些學習心得寫出。這樣大家可以更快的了解CRC32的主要思想。由於水平有限，還懇請大家指正。原文可以訪問：http://www.repairfaq.org/filipg/LINK/F_crc_v31.html 。
二：基本概念及相關介紹
2．1 什麼是CRC
在遠距離數據通信中，為確保高效而無差錯地傳送數據，必須對數據進行校驗即差錯控制。循環冗餘校驗CRC(Cyclic Rendancy Check/Code)是對一個傳送數據塊進行校驗，是一種高效的差錯控制方法。
CRC校驗採用多項式編碼方法。多項式乘除法運算過程與普通代數多項式的乘除法相同。多項式的加減法運算以2為模，加減時不進，錯位，如同邏輯異或運算。
2．2 CRC的運算規則
CRC加法運算規則：0+0=0
0+1=1
1+0=1
1+1=0 (注意：沒有進位)
CRC減法運算規則：
0-0=0
0-1=1
1-0=1
1-1=0
CRC乘法運算規則：
0*0=0
0*1=0
1*0=0
1*1=1
CRC除法運算規則：
1100001010 (注意:我們並不關心商是多少。)
_______________
10011 11010110110000
10011,,.,,....
-----,,.,,....
10011,.,,....
10011,.,,....
-----,.,,....
00001.,,....
00000.,,....
-----.,,....
00010,,....
00000,,....
-----,,....
00101,....
00000,....
-----,....
01011....
00000....
-----....
10110...
10011...
-----...
01010..
00000..
-----..
10100.
10011.
-----.
01110
00000
-----
1110 = 余數
2．3 如何生成CRC校驗碼
(1) 設G(X)為W階，在數據塊末尾添加W個0，使數據塊為M+ W位，則相應的多項式為XrM(X)；
(2) 以2為模，用對應於G(X)的位串去除對應於XrM(X)的位串，求得余數位串；
(3) 以2為模，從對應於XrM(X)的位串中減去余數位串，結果就是為數據塊生成的帶足夠校驗信息的CRC校驗碼位串。
2．4 可能我們會問那如何選擇G(x)
可以說選擇G(x)不是一件很容易的事。一般我們都使用已經被大量的數據，時間檢驗過的，正確的，高效的，生成多項式。一般有以下這些：
16 bits: (16,12,5,0) [X25 standard]
(16,15,2,0) ["CRC-16"]
32 bits: (32,26,23,22,16,12,11,10,8,7,5,4,2,1,0) [Ethernet]
三: 如何用軟體實現CRC演算法
現在我們主要問題就是如何實現CRC校驗，編碼和解碼。用硬體實現目前是不可能的，我們主要考慮用軟體實現的方法。
以下是對作者的原文的翻譯：
我們假設有一個4 bits的寄存器，通過反復的移位和進行CRC的除法，最終該寄存器中的值就是我們所要求的余數。
3 2 1 0 Bits
+---+---+---+---+
Pop <-- | | | | | <----- Augmented message（已加0擴張的原始數據）
+---+---+---+---+
1 0 1 1 1 = The Poly
(注意: The augmented message is the message followed by W zero bits.)
依據這個模型，我們得到了一個最最簡單的演算法：
把register中的值置0.
把原始的數據後添加r個0.
While (還有剩餘沒有處理的數據)
Begin
把register中的值左移一位，讀入一個新的數據並置於register的0 bit的位置。
If (如果上一步的左移操作中的移出的一位是1)
register = register XOR Poly.
End
現在的register中的值就是我們要求的crc余數。
我的學習筆記：
可為什麼要這樣作呢？我們從下面的實例來說明：
1100001010
_______________
10011 11010110110000
10011,,.,,....
-----,,.,,....
－》 10011,.,,....
10011,.,,....
-----,.,,....
－》 00001.,,....
00000.,,....
-----.,,....
00010,,....
00000,,....
-----,,....
00101,....
00000,....
我們知道G(x)的最高位一定是1，而商1還是商0是由被除數的最高位決定的。而我們並不關心商究竟是多少，我們關心的是余數。例如上例中的G(x)有5 位。我們可以看到每一步作除法運算所得的余數其實就是被除數的最高位後的四位於G(x)的後四位XOR而得到的。那被除數的最高位有什麼用呢？我們從打記號的兩個不同的余數就知道原因了。當被除數的最高位是1時，商1然後把最高位以後的四位於G(x)的後四位XOR得到余數；如果最高位是0，商0然後把被除數的最高位以後的四位於G(x)的後四位XOR得到余數，而我們發現其實這個余數就是原來被除數最高位以後的四位的值。也就是說如果最高位是0就不需要作XOR的運算了。到這我們總算知道了為什麼先前要這樣建立模型，而演算法的原理也就清楚了。
以下是對作者的原文的翻譯：
可是這樣實現的演算法卻是非常的低效。為了加快它的速度，我們使它一次能處理大於4 bit的數據。也就是我們想要實現的32 bit的CRC校驗。我們還是假設有和原來一樣的一個4 "bit"的register。不過它的每一位是一個8 bit的位元組。
3 2 1 0 Bytes
+----+----+----+----+
Pop <-- | | | | | <----- Augmented message
+----+----+----+----+
1<------32 bits------> （暗含了一個最高位的「1」）
根據同樣的原理我們可以得到如下的演算法：
While (還有剩餘沒有處理的數據)
Begin
檢查register頭位元組，並取得它的值
求不同偏移處多項式的和
register左移一個位元組，最右處存入新讀入的一個位元組
把register的值和多項式的和進行XOR運算
End
我的學習筆記：
可是為什麼要這樣作呢？ 同樣我們還是以一個簡單的例子說明問題：
假設有這樣的一些值：
當前register中的值： 01001101
4 bit應該被移出的值：1011
生成多項式為： 101011100
Top Register
---- --------
1011 01001101
1010 11100 + (CRC XOR)
-------------
0001 10101101
首4 bits 不為0說明沒有除盡，要繼續除:
0001 10101101
1 01011100 + (CRC XOR)
-------------
0000 11110001
^^^^
首4 bits 全0說明不用繼續除了。
那按照演算法的意思作又會有什麼樣的結果呢？
1010 11100
1 01011100+
-------------
1011 10111100
1011 10111100
1011 01001101+
-------------
0000 11110001
現在我們看到了這樣一個事實，那就是這樣作的結果和上面的結果是一致的。這也說明了演算法中為什麼要先把多項式的值按不同的偏移值求和，然後在和 register進行異或運算的原因了。另外我們也可以看到，每一個頭位元組對應一個值。比如上例中：1011，對應01001101。那麼對於 32 bits 的CRC 頭位元組，依據我們的模型。頭8 bit就該有 2^8個，即有256個值與它對應。於是我們可以預先建立一個表然後，編碼時只要取出輸入數據的頭一個位元組然後從表中查找對應的值即可。這樣就可以大大提高編碼的速度了。
+----+----+----+----+
+-----< | | | | | <----- Augmented message
| +----+----+----+----+
| ^
| |
| XOR
| |
| 0+----+----+----+----+
v +----+----+----+----+
| +----+----+----+----+
| +----+----+----+----+
| +----+----+----+----+
| +----+----+----+----+
| +----+----+----+----+
+-----> +----+----+----+----+
+----+----+----+----+
+----+----+----+----+
+----+----+----+----+
+----+----+----+----+
255+----+----+----+----+
以下是對作者的原文的翻譯：
上面的演算法可以進一步優化為：
1：register左移一個位元組,從原始數據中讀入一個新的位元組.
2：利用剛從register移出的位元組作為下標定位 table 中的一個32位的值
3：把這個值XOR到register中。
4：如果還有未處理的數據則回到第一步繼續執行。
用C可以寫成這樣：
r=0;
while (len--)
r = ((r << | p*++) ^ t[(r >> 24) & 0xFF];
可是這一演算法是針對已經用0擴展了的原始數據而言的。所以最後還要加入這樣的一個循環，把W個0加入原始數據。
我的學習筆記：
注意不是在預處理時先加入W個0，而是在上面演算法描述的循環後加入這樣的處理。
for (i=0; i<W/4; i++)
r = (r << ^ t[(r >> 24) & 0xFF];
所以是W/4是因為若有W個0，因為我們以位元組（8位）為單位的，所以是W/4個0 位元組。注意不是循環w/8次
以下是對作者的原文的翻譯：
1：對於尾部的w/4個0位元組，事實上它們的作用只是確保所有的原始數據都已被送入register，並且被演算法處理。
2：如果register中的初始值是0，那麼開始的4次循環，作用只是把原始數據的頭4個位元組送入寄存器。（這要結合table表的生成來看）。就算 register的初始值不是0，開始的4次循環也只是把原始數據的頭4個位元組把它們和register的一些常量XOR，然後送入register中。
3A xor B) xor C = A xor (B xor C)
總上所述，原來的演算法可以改為:
+-----<Message (non augmented)
|
v 3 2 1 0 Bytes
| +----+----+----+----+
XOR----<| | | | |
| +----+----+----+----+
| ^
| |
| XOR
| |
| 0+----+----+----+----+
v +----+----+----+----+
| +----+----+----+----+
| +----+----+----+----+
| +----+----+----+----+
| +----+----+----+----+
| +----+----+----+----+
+----->+----+----+----+----+
+----+----+----+----+
+----+----+----+----+
+----+----+----+----+
+----+----+----+----+
255+----+----+----+----+
演算法：
1：register左移一個位元組,從原始數據中讀入一個新的位元組.
2：利用剛從register移出的位元組和讀入的新位元組XOR從而產生定位下標，從table中取得相應的值。
3：把該值XOR到register中
4：如果還有未處理的數據則回到第一步繼續執行。
我的學習筆記：
對這一演算法我還是不太清楚，或許和XOR的性質有關，懇請大家指出為什麼？
謝謝。
到這，我們對CRC32的演算法原理和思想已經基本搞清了。下章，我想著重根據演算法思想用java語言實現。
hjzgq 回復於：2003-05-15 14:14:51
數學演算法一向都是密碼加密的核心，但在一般的軟路加密中，它似乎並不太為人們所關心，因為大多數時候軟體加密本身實現的都是一種編程上的技巧。但近幾年來隨著序列號加密程序的普及，數學演算法在軟體加密中的比重似乎是越來越大了。
我們先來看看在網路上大行其道的序列號加密的工作原理。當用戶從網路上下載某個Shareware -- 共享軟體後，一般都有使用時間上的限制，當過了共享軟體的試用期後，你必須到這個軟體的公司去注冊後方能繼續使用。注冊過程一般是用戶把自己的私人信息（一般主要指名字）連同信用卡號碼告訴給軟體公司，軟體公司會根據用戶的信息計算出一個序列碼出來，在用戶得到這個序列碼後，按照注冊需要的步驟在軟體中輸入注冊信息和注冊碼，其注冊信息的合法性由軟體驗證通過後，軟體就會取消掉本身的各種限制。這種加密實現起來比較簡單，不需要額外的成本，用戶購買也非常方便，在網上的軟體80%都是以這種方式來保護的。
我們可以注意到軟體驗證序列號的合法性過程，其實就是驗證用戶名與序列號之間的換算關系是否正確的過程。其驗證最基本的有兩種，一種是按用戶輸入的姓名來生成注冊碼，再同用戶輸入的注冊碼相比較，公式表示如下：
序列號 = F(用戶名稱)
G. java 登陸時的驗證碼怎麼做
後台寫一個生成圖片隨機的代碼，生成圖片給前台。切換圖片的時候，使用ajax獲取圖片數據就行。
附上生成圖片的代碼
public class ValidateCode {
private int width=180;
private int height=60;
private int codeCount = 4;
private int x = 0;
private int codeY;
private String Code;
private BufferedImage buffImg;
static char[] codeSequence = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z','a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
'x', 'y', 'z', 'o', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
private int fontHeight;
public ValidateCode() {
x = width / (codeCount + 2);
fontHeight = height - 2;
codeY = height - 4;
CreateCode();
}
public void CreateCode(){
// 定義圖像buffer
BufferedImage buffImg = new BufferedImage(width, height,BufferedImage.TYPE_INT_RGB);
Graphics2D g = buffImg.createGraphics();
// 創建一個隨機數生成器類
Random random = new Random();
// 將圖像填充為白色
g.setColor(Color.WHITE);
g.fillRect(0, 0, width, height);
// 創建字體，字體的大小應該根據圖片的高度來定。
Font font = new Font("Fixedsys", Font.PLAIN, fontHeight);
// 設置字體。
g.setFont(font);
// 畫邊框。
g.setColor(Color.BLACK);
g.drawRect(0, 0, width - 1, height - 1);
// randomCode用於保存隨機產生的驗證碼，以便用戶登錄後進行驗證。
StringBuffer randomCode = new StringBuffer();
int red = 0, green = 0, blue = 0;
// 隨機產生codeCount數字的驗證碼。
for (int i = 0; i < codeCount; i++) {
// 得到隨機產生的驗證碼數字。
String strRand = String.valueOf(codeSequence[random.nextInt(62)]);
// 產生隨機的顏色分量來構造顏色值，這樣輸出的每位數字的顏色值都將不同。
red = random.nextInt(255);
green = random.nextInt(255);
blue = random.nextInt(255);
// 用隨機產生的顏色將驗證碼繪制到圖像中。
g.setColor(new Color(red, green, blue));
g.drawString(strRand, (i ) * x+20, codeY);
// 將產生的四個隨機數組合在一起。
randomCode.append(strRand);
}
this.Code=randomCode.toString().toUpperCase();
this.buffImg=buffImg;
}
public String getCode() {
return Code;
}
public void setCode(String code) {
Code = code;
}
public BufferedImage getBuffImg() {
return buffImg;
}
public void setBuffImg(BufferedImage buffImg) {
this.buffImg = buffImg;
}
}