java比較演算法
就好比問，漢語中常用寫作方法有多少種，怎麼分類。
演算法按用途分,體現設計目的、有什麼特點
演算法按實現方式分，有遞歸、迭代、平行、序列、過程、確定、不確定等等
演算法按設計范型分，有分治、動態、貪心、線性、圖論、簡化等等
作為圖靈完備的語言，理論上」Java語言「可以實現所有演算法。
「Java的標准庫'中用了一些常用數據結構和相關演算法.
像apache common這樣的java庫中又提供了一些通用的演算法
② 求一個比較大小的JAVA演算法
1.是的
2.a-可以直接求和，b-利用近似公式
3.近似公式為e=(1+1/n)^n,n->無窮大
4.這兩個公式都需要運算n到足夠大來減少誤差
假如你運算到n=k滿足精度需要了
那麼你首先要保證當n=k-1時算出的值與n=k的值差別小於0.0001
假如需要考慮截斷誤差，那麼你就要考慮到任何一個1/n或者1/n!的形式的截斷誤差，以及運算中每一步的累計誤差，都是可以計算的
從累積誤差的角度來說，第一個方法較優
因為每一個求和項目都是整數的倒數，只發生一次截斷
之後的誤差計算直接將最大誤差可能求和就可以了
而且每一次迭代可以應用上一次的結果，效率較高
但是缺點是當n比較大的時候，n!也會是一個比較大的數，n的類型定義得不好會溢出
第二個方法就需要計算一次截斷誤差，並且計算n次方的誤差累積
③ java比較2個文件是否是相同的文件，是一個一個位元組比較還是計算MD5比較好啊
不同內容得出相同MD5值，雖然概率低，但總是不放心。如果在已知文件編碼范圍的條件下，找到MD5絕對區分長度范圍（即：該范圍內取樣內容的MD5相同的，內容保證相同；絕不存在不同內容得出相同MD5值的現象），那麼，可按合理的長度分片、按一定順序遍歷整個文件(屬性信息、頭部、尾部、同步隨機點、其他)，比較MD5，一旦有異立即判定文件不同，終止比較。這種分片取樣比較MD5的思路可能快於逐位元組比較也絕對可信
要確保 100%正確就必須校驗全文，通過以上思路來比較，即是。
（註：
其他據說相對於MD5來講不易碰撞（即不同內容得出相同MD5值的概率可能更低）的演算法推薦：起碼 SHA1 ，最好 SHA256、 SHA512、MD5+CRC32、HMAC，或者幾種不同類型演算法的同步進行。
在精通演算法的情況下，將這里推薦的演算法取代上文中提到的MD5來考量，能擴大絕對區分長度范圍，可能更方便更快的比較。
但是又有這樣的考慮：逐位元組比較的演算法最簡單，演算法弄復雜了反而會增加額余的時間；逐位元組比較的演算法也可以放到上文中來考量，進行同步取樣和各種遍歷的順序與方式，說不定，在保證100%的可信度的條件下，逐字比較反而最快呢?
我覺得時間的耗費關鍵處在於，所有的演算法，都要將兩個位於不同區域或載體的文件的同位區域收集到一起進行比較，這個收集花費時間Ta(i)，與取樣長度、存儲區域或載體等相關；{如果要將文件取很大一部或全部讀入內存，然後再逐一集中比較，則會減小以上的Ta(i)，而增加一個額外讀入的時間Tc(i)*次數M(i)}。比較的次數大致為N(i)；而如果在一個文件中順序讀取一個區域並且計算它的某個整體評定值，這個花費的時間為Tb(i)，與取樣長度、計算程序、設備性能等相關。
總體的比較時間大致是Ta(i)*N(i)*Tb(i)+{Tc(i)*M(i)}
逐位元組比較，其中Tb(i)、Ta(i)都是最短的，但是N(i)最大，
總之，可以設計不同的演算法，通過實際環境和文件的檢測，來決定採用何種演算法。
）
外一則：
兩個取樣內容， MD5等演算法的計算值 不同，則內容一定不同； 計算值相同，則 內容可能相同，但可能性是否達到100%，內容相同的概率是多少，根據編碼范圍、演算法來確定。如果是比較一個文件和許多其他文件是否相同，並且提前知道其他文件的 MD5 值，可先比較 MD5 值可以大大提高文件比較的速度。
④ java如何比較一維數組大小
boolean isEqual(int[] a, int b[])
{
int n = a.length;
if(n != b.length) //數組長度銷耐不相等 返回false
return false;
for(int i =0 ;i <n;i++)
{
if(a[i] != b[i]) //對應元素不塵斗豎相派大等 返回false
{
return false;
}
}
return true; //長度相等 對應元素也相等 返回true
}
}
⑤ Java單多線程求pair值演算法比較
進程和線程的概念
什麼是進程
一個進程就是在一個運行的程序 它有自己獨立的內存空間 一組系統資源 每個進程的內部數據和狀態都是獨立的 例如在window是同時打開多個記事本 雖然它們所運行的程序代碼都是一樣的 但是所使用的內存空間是獨立的 互不幹擾
什麼是線程
線程與進程相似 是一段完成某個特定功能的代碼 是程序中單個順序的流控制;但與進程不同的是 同類的多個線程共享一塊內存空間和一組系統資源 而線程本身的數據通常只有微處理器的寄存器數據 以及一個供程序執行時使用的堆棧
進程與線程的區別
進程:每個進程都有獨立的代碼和數據空間(進程上下文) 進程切換的開銷大
線程:輕量的進程 同一類線程共享代碼和數據空間 每個線程有獨立的運行棧和程序計數器(PC) 線程切換的開銷小
多進程:在操作系統中 能同時運行多個任務程序
多線程:在同一應用程序中 有多個順序流同時執行
線程創豎態梁建的兩種方式
採用繼承Thread類創建線程
該方法比較簡單 主要是通過繼承java lang Thread類 並覆蓋Thread類的run()方法來完成線成的創建 Thread 類是一個具體的閉悄類 即不是抽象類 該類封裝了線程的行為 要創建一個線程 程序員必須創建一個從 Thread 類導出的新類 Thread類中有兩個最重要的函數run()和start()
通過實現Runnable介面創建線程
該方法通過生成實現java lang Runnable介面的類 該介面只定義了一個方法run() 所以必須余運在新類中實現它 但是 Runnable 介面並沒有任何對線程的支持 我們還必須創建 Thread 類的實例 這一點通過 Thread 類的構造函數
public Thread(Runnable target);來實現
單線程和多線程性能比較
以使用蒙特卡羅概率演算法求π為例 進行單線程和多線程時間比較
什麼是蒙特卡羅概率演算法
蒙特卡羅法(Monte Carlo method)是以概率和統計的理論 方法為基礎的一種計算方法 將所求解的問題同一定的概率模型相聯系 用電子計算機實現統計模擬或抽樣 以獲得問題的近似解 故又稱統計模擬法或統計試驗法 網路
蒙特卡羅求演算法求π
第一步
畫正方形和內切圓
第二步
變換表達式
正方形面積As=( R)^
圓的面積Ac=πR^
Ac/As=( R)^ /πR^
π= As/Ac
令P=As/Sc 則π= P
第三步
重復N次實驗求平均值
在正方形區域內隨機生成一個點A 若A落在圓區域內 M++
P=M/N
π= P N的取值越大 π的值越精確
java代碼實現演算法
N取值為 萬 多線程的數為 每個線程執行 萬次模擬實驗
線程實現
import ncurrent CountDownLatch;
public class ProModel implements Runnable {
public int N;//隨機實驗的總次數
public static int M;//隨機點落在圓中的次數
private int id;
private final CountDownLatch doneSignal;
OBJ semaphore;
public ProModel(int id CountDownLatch doneSignal int N OBJ semaphore ){
this id=id;
this doneSignal=doneSignal;
this N=N;
this semaphore=semaphore ;
M= ;
}
public void run(){
int tempM= ;
for(int i= ;i<N;i++){
if(isInCircle()){
tempM++;
}
}
synchronized (semaphore) {
add(tempM);
}
untDown();//使end狀態減
}
public void add(int tempM){
System out println(Thread currentThread() getName());
M=M+tempM;
System out println(M);
}
//隨機產生一個在正方形區域的點 判斷它是否在圓中
public boolean isInCircle(){
double x=Math random();
double y=Math random();
if((x )*(x )+(y )*(y )< )
return true;
else
return false;
}
public static int getTotal(){
return M;
}
}
多線程Main實現
import ncurrent CountDownLatch;
import ncurrent ExecutorService;
import ncurrent Executors;
public class MutliThread {
public static void main(String[] args) throws InterruptedException {
long begin=System currentTimeMillis();
int threadSize= ;
int N= ;
OBJ semaphore = new OBJ();
CountDownLatch doneSignal = new CountDownLatch(threadSize);
ProModel[] pros=new ProModel[threadSize];
//設置特定的線程池 大小為threadSizde
System out println( begins! );
ExecutorService exe = Executors newFixedThreadPool(threadSize);
for(int i= ;i<threadSize;i++)
exe execute(new ProModel(i+ doneSignal N semaphore));
try{
doneSignal await(); //等待end狀態變為 }catch (InterruptedException e) {
// TODO: handle exception
e printStackTrace();
}finally{
System out println( ends! );
System out println( *(float)ProModel getTotal()/(float)(threadSize*N));
}
exe shutdown();
long end=System currentTimeMillis();
System out println( used time(ms): +(end begin));
}
}
class OBJ{}
單線程Main實現
import ncurrent CountDownLatch;
import ncurrent ExecutorService;
import ncurrent Executors;
public class SingleThread {
public static void main(String[] args) {
long begin=System currentTimeMillis();
int threadSize= ;
int N= ;
OBJ semaphore = new OBJ();
CountDownLatch doneSignal = new CountDownLatch(threadSize);
ProModel[] pros=new ProModel[threadSize];
//設置特定的線程池 大小為
System out println( begins! );
ExecutorService exe = Executors newFixedThreadPool(threadSize);
for(int i= ;i<threadSize;i++)
exe execute(new ProModel(i+ doneSignal N semaphore));
try{
doneSignal await(); //等待end狀態變為 }catch (InterruptedException e) {
// TODO: handle exception
e printStackTrace();
}finally{
System out println( ends! );
System out println( *(float)ProModel getTotal()/(float)(threadSize*N));
}
exe shutdown();
long end=System currentTimeMillis();
System out println( used time(ms): +(end begin));
}
}
運行結果比較
lishixin/Article/program/Java/gj/201311/27648
⑥ java實現幾種常見排序演算法
下面給你介紹四種常用排序演算法：
1、冒泡排序
特點：效率低，實現簡單
思想（從小到大排）：每一趟將待排序序列中最大元素移到最後，剩下的為新的待排序序列，重復上述步驟直到排完所有元素。這只是冒泡排序的一種，當然也可以從後往前排。
⑦ Java單多線程求pair值演算法比較
單線程比多線程更快。你的測試代碼只是用了CPU資源。因為多線程需要處理線顫改程的開銷，開銷多了自然沒有單線程快。
多線程是為了更充分的利用計算機的資源。比如網路,IO,CPU...如果你在for循環里芹洞此加入一個磁碟寫入操作，多嫌迅線程就會比單線程快了
⑧ java 比較大小演算法
排序用建議實現comparable類吧 自定義排序比較的參數 否則對象是沒法比較大小的 只能比較是否相等
class One implements Comparable{
int age;
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
One one = (One)o;
if(one.age > this.age)
return -1;
else if( one.age < this.age)
return 1;
else
return 0;
}
}
大概這個意思 這是對象比較大小
對象數組同樣也這樣比較，數值數組直接循環比較就行
⑨ 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三個數排序比較大小的完整代碼，並給出詳細解釋，初學者，謝謝
import java.util.Arrays;
import java.util.Collection;
public class Demo2 {
public static void main(String[] args) {
// 這是你的三個數
int[] arr = { 12, 32, 18 };
// 兩層嵌套循環
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < i; j++) {
// 如果後者小於前者，讓他們交換位置，一直循環
// 直到每個數字都從頭到尾跟數組里的每個數字比較一次
if (arr[i] < arr[j]) {
// 這三步就是交換位置，相信聰明的你一定看得懂了
arr[i] = arr[i] + arr[j];
arr[j] = arr[i] - arr[j];
arr[i] = arr[i] - arr[j];
}
}
}
//最後列印出來
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
資料拓展：
Java是一門面向對象編程語言，不僅吸收了C++語言的各種優點，還摒棄了C++里難以理解的多繼承、指針等概念，因此Java語言具有功能強大和簡單易用兩個特徵。Java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論