面試查詢演算法

『壹』 面試演算法題一般給多少時間

主要是讓你用計算機就可以啊

『貳』 java面試有哪些演算法

面試-java演算法題：
1.編寫一個程序，輸入n,求！（用遞歸的方式實現）。
public static long fac(int n){ if(n<=0) return 0; else if(n==1) return 1; else return n*fac(n-1);
} public static void main(String [] args) {
System.out.println(fac(6));
}
2.編寫一個程序，有1，2,3,4個數字，能組成多少個互不相同且無重復數字的三位數？都是多少？
public static void main(String [] args) { int i, j, k; int m=0; for(i=1;i<=4;i++) for(j=1;j<=4;j++) for(k=1;k<=4;k++){ if(i!=j&&k!=j&&i!=k){
System.out.println(""+i+j+k);
m++;
}
}
System.out.println("能組成："+m+"個");
}
3.編寫一個程序，將text1.txt文件中的單詞與text2.txt文件中的單詞交替合並到text3.txt文件中。text1.txt文件中的單詞用回車符分隔，text2.txt文件中用回車或空格進行分隔。
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class text{
public static void main(String[] args) throws Exception{
String[] a = getArrayByFile("text1.txt",new char[]{'\n'});
String[] b = getArrayByFile("text2.txt",new char[]{'\n',' '});
FileWriter c = new FileWriter("text3.txt");
int aIndex=0; int bIndex=0;

while(aIndex<a.length){
c.write(a[aIndex++] + "\n");
if(bIndex<b.length)
c.write(b[bIndex++] + "\n");
}

while(bIndex<b.length){
c.write(b[bIndex++] + "\n");
}
c.close();
}

public static String[] getArrayByFile(String filename,char[] seperators) throws Exception{
File f = new File(filename);
FileReader reader = new FileReader(f);
char[] buf = new char[(int)f.length()];
int len = reader.read(buf);
String results = new String(buf,0,len);
String regex = null;
if(seperators.length >1 ){
regex = "" + seperators[0] + "|" + seperators[1];
}else{
regex = "" + seperators[0];
}
return results.split(regex);
}

}
4.639172每個位數上的數字都是不同的，且平方後所得數字的所有位數都不會出現組成它自身的數字。（639172*639172=408540845584），類似於639172這樣的6位數還有幾個？分別是什麼？
這題採用的HashMap結構判斷有無重復，也可以採用下題的數組判斷。
public void selectNum(){
for(long n = 100000; n <= 999999;n++){
if(isSelfRepeat(n)) //有相同的數字，則跳過
continue;
else if(isPingFangRepeat(n*n,n)){ //該數的平方中是否有與該數相同的數字
continue;
} else{ //符合條件，則列印 System.out.println(n);
}
}
} public boolean isSelfRepeat(long n){
HashMap<Long,String> m=new HashMap<Long,String>(); //存儲的時候判斷有無重復值
while(n!=0){ if(m.containsKey(n%10)){ return true;
} else{
m.put(n%10,"1");
}
n=n/10;
} return false;
} public boolean isPingFangRepeat(long pingfang,long n){
HashMap<Long,String> m=new HashMap<Long,String>(); while(n!=0){
m.put(n%10,"1");
n=n/10;
} while(pingfang!=0){ if(m.containsKey(pingfang%10)){ return true;
}
pingfang=pingfang/10;
} return false;
} public static void main(String args[]){ new test().selectNum();
}
5.比如，968548+968545=321732732它的答案里沒有前面兩個數里的數字，有多少這樣的6位數。
public void selectNum(){
for(int n = 10; n <= 99;n++){
for(int m = 10; m <= 99;m++){ if(isRepeat(n,m)){ continue;
} else{
System.out.println("組合是"+n+","+m);
}
}
}
} public boolean isRepeat(int n,int m){ int[] a={0,0,0,0,0,0,0,0,0,0}; int s=n+m; while(n!=0){
a[n%10]=1;
n=n/10;
} while(m!=0){
a[m%10]=1;
m=m/10;
} while(s!=0){ if(a[s%10]==1){ return true;
}
s=s/10;
} return false;
} public static void main(String args[]){ new test().selectNum();
}
6.給定String,求此字元串的單詞數量。字元串不包括標點，大寫字母。例如 String str="hello world hello hi";單詞數量為3，分別是：hello world hi。
public static void main(String [] args) { int count = 0;
String str="hello world hello hi";
String newStr="";
HashMap<String,String> m=new HashMap<String,String>();
String [] a=str.split(" "); for (int i=0;i<a.length;i++){ if(!m.containsKey(a[i])){
m.put(a[i],"1");
count++;
newStr=newStr+" "+a[i];
}
}
System.out.println("這段短文單詞的個數是："+count+","+newStr);
}
7.寫出程序運行結果。
public class Test1 { private static void test(int[]arr) { for (int i = 0; i < arr.length; i++) { try { if (arr[i] % 2 == 0) { throw new NullPointerException();
} else {
System.out.print(i);
}
} catch (Exception e) {
System.out.print("a ");
} finally {
System.out.print("b ");
}
}
}
public static void main(String[]args) { try {
test(new int[] {0, 1, 2, 3, 4, 5});
} catch (Exception e) {
System.out.print("c ");
}
}

}
運行結果：a b 1b a b 3b a b 5b
public class Test1 { private static void test(int[]arr) { for (int i = 0; i < arr.length; i++) { try { if (arr[i] % 2 == 0) { throw new NullPointerException();
} else {
System.out.print(i);
}
}
finally {
System.out.print("b ");
}
}
}
public static void main(String[]args) { try {
test(new int[] {0, 1, 2, 3, 4, 5});
} catch (Exception e) {
System.out.print("c ");
}
}

}
運行結果：b c
8.單詞數
統計一篇文章里不同單詞的總數。
Input
有多組數據，每組一行，每組就是一篇小文章。每篇小文章都是由小寫字母和空格組成，沒有標點符號，遇到#時表示輸入結束。
Output
每組值輸出一個整數，其單獨成行，該整數代表一篇文章里不同單詞的總數。
Sample Input
you are my friend
#
Sample Output
4
public static void main(String [] args) {
List<Integer> countList=new ArrayList<Integer>(); int count;
HashMap<String,String> m;
String str; //讀取鍵盤輸入的一行（以回車換行為結束輸入） String[] a;

Scanner in=new Scanner(System.in);
while( !(str=in.nextLine()).equals("#") ){
a=str.split(" ");
m=new HashMap<String,String>();
count = 0; for (int i=0;i<a.length;i++){ if(!m.containsKey(a[i]) && (!a[i].equals(""))){
m.put(a[i],"1");
count++;
}
}
countList.add(count);
}s for(int c:countList)
System.out.println(c);
}

『叄』 綜合成績計算方法到底咋算筆試、面試4、6開怎麼個演算法呀

以前看過一個帖子（經認領是豬哥的帖子）貌似是(筆試分*100/250)*0.4+面試分*0.6所以是0.16

『肆』 求解公務員面試成績演算法

你是安徽的吧 只有安徽的才6比4
16.35 就是筆試差除2再乘1.5

難度很大 你加油吧

『伍』 一道面試演算法題

這是典型的桶排序演算法，
假設有9個桶，每個桶里存放N個數字。桶應該是唯一的。
所以推出結論：
1。桶是唯一的（我們因此可以利用Hashtable的唯一性來做到）；
2。桶內成員可以不排序，因此可以利用數組或者Vector來做到；
3。Hashtable需要主鍵key來唯一標識，正好數字1~9是不重復的，是唯一的；
3。把每個數值的第一位取出來，以第一位值做為key找到hashtable中的相應vector，再將vector.addElements(該數值);
4。完成;

具體做法：
1.生成桶，9個桶，每個桶以數字1~9做為主鍵命名
Hashtable table=new Hashtable();
for(int i=1;i<10;i++){
Vector vector=new Vector();
table.put(new String(i), vector);
}
2. 遍歷每個數字，將當前數字的第一位分解出來，辦法有很多種，比如除十法，這里介紹直接轉字元串再取第一位法：
假設你的要處理的數字們放在數組裡面int[] tmp;
for(int i=0;i<tmp.length;i++){
int num=tmp[i];
String str=new String(num);
char ch=str.charAt(0);
//壓入到桶里，先把想要的桶找到，利用主鍵
Vector vect=(Vector)table.get(""+ch);
//找到桶後再把數值壓到桶里
vect.addElements(new Integer(num));
}

//取出來的時候，有多種方法，一種是利用key取出Vector,再遍歷Vector，得到其中元素，元素的key為String, 內容為Integer

另一種方法是先遍歷hashtable再遍歷vector

同樣的應用還有給一幅被洗過的撲克牌進行升或降排棄，因此可以建13個桶(A~K)，每個桶內的牌再按花色排序（相當於對Vector排序，也可以不用Vector而直接用數組或者ArrayList等等）

我看了你的修改提問，現回答如下：
即使不能使用java己經封裝好的Hashtable類，自己也可以很輕易地利用代碼編寫出類似於Hashtable的集合類，用來包容其它對象，並以主鍵key來唯一標識.

如果你不想這樣思考，那麼直接用數組來實現桶排序也很方便，外層數組長度是固定的，即1~9共9個數組元素 Elements e=new Elements[9]。
這九個數組元素不是數字，必須是你自定義的類。並用這個類形成鏈表結構
比如：
public class Element{
int data;//存數字
Element next=null;//下一個元素是誰
}
比如有數字 51,52,53 這三個數都是以5打頭，那麼他們應該放在一個桶裡面，即第五號桶，也就是外層數組的第個元素中。

if( 判斷該數字，是否應該放在5號桶){
Elements tmp=new Elements();
tmp.data=該數字;
Elements current=e[4];
if(current==null){current=tmp;}//如果該桶以前從未放過數字，則放進去的就是頭部，直接引用就行了，比如51應該放在頭部
else{//如果該桶以前己經放過數字，如51,己經放了，現在放52。52就應該做為51的next元素，而53就是52的next就行了
while(current!=null){current=current.next;}//遍歷，從而取到最後一個元素的引用
//取到最後一個元素後，current=tmp;即可,這樣就形成了鏈表結構
}
}

通過上述代表形成的結果是， 外層結構是9個元素組成的數組
每個數組元素是Elements類對象形成的鏈表結構,有頭有層通過next欄位串連起來。
如果要排序，只需要對每個鏈表內部進行排序就可以了

『陸』 要面試演算法工程師，大神給點相關經驗啊

演算法是比較復雜又基礎的學科，每個學編程的人都會學習大量的演算法。而根據統計，以下這18個問題是面試中最容易遇到的，本文給出了一些基本答案，供演算法方向工程師或對此感興趣的程序員參考。
1)請簡單解釋演算法是什麼?
演算法是一個定義良好的計算過程，它將一些值作為輸入並產生相應的輸出值。簡單來說，它是將輸入轉換為輸出的一系列計算步驟。
2)解釋什麼是快速排序演算法?
快速排序演算法能夠快速排序列表或查詢。它基於分割交換排序的原則，這種類型的演算法佔用空間較小，它將待排序列表分為三個主要部分：
·小於Pivot的元素
·樞軸元素Pivot(選定的比較值)
·大於Pivot的元素
3)解釋演算法的時間復雜度?
演算法的時間復雜度表示程序運行完成所需的總時間，它通常用大O表示法來表示。
4)請問用於時間復雜度的符號類型是什麼?
用於時間復雜度的符號類型包括：
·Big Oh：它表示小於或等於目標多項式
·Big Omega：它表示大於或等於目標多項式
·Big Theta：它表示與目標多項式相等
·Little Oh：它表示小於目標多項式
·Little Omega：它表示大於目標多項式
5)解釋二分法檢索如何工作?
在二分法檢索中，我們先確定數組的中間位置，然後將要查找的值與數組中間位置的值進行比較，若小於數組中間值，則要查找的值應位於該中間值之前，依此類推，不斷縮小查找范圍，直至得到最終結果。
6)解釋是否可以使用二分法檢索鏈表?
由於隨機訪問在鏈表中是不可接受的，所以不可能到達O(1)時間的中間元素。因此，對於鏈表來說，二分法檢索是不可以的(對順序鏈表或排序後的鏈表是可以用的)。
7)解釋什麼是堆排序?
堆排序可以看成是選擇排序的改進，它可以定義為基於比較的排序演算法。它將其輸入劃分為未排序和排序的區域，通過不斷消除最小元素並將其移動到排序區域來收縮未排序區域。
8)說明什麼是Skip list?
Skip list數據結構化的方法，它允許演算法在符號表或字典中搜索、刪除和插入元素。在Skip list中，每個元素由一個節點表示。搜索函數返回與key相關的值的內容。插入操作將指定的鍵與新值相關聯，刪除操作可刪除指定的鍵。
9)解釋插入排序演算法的空間復雜度是多少?
插入排序是一種就地排序演算法，這意味著它不需要額外的或僅需要少量的存儲空間。對於插入排序，它只需要將單個列表元素存儲在初始數據的外側，從而使空間復雜度為O(1)。
10)解釋什麼是「哈希演算法」，它們用於什麼?
「哈希演算法」是一個哈希函數，它使用任意長度的字元串，並將其減少為唯一的固定長度字元串。它用於密碼有效性、消息和數據完整性以及許多其他加密系統。
11)解釋如何查找鏈表是否有循環?
要知道鏈表是否有循環，我們將採用兩個指針的方法。如果保留兩個指針，並且在處理兩個節點之後增加一個指針，並且在處理每個節點之後，遇到指針指向同一個節點的情況，這只有在鏈表有循環時才會發生。
12)解釋加密演算法的工作原理?
加密是將明文轉換為稱為「密文」的密碼格式的過程。要轉換文本，演算法使用一系列被稱為「鍵」的位來進行計算。密鑰越大，創建密文的潛在模式數越多。大多數加密演算法使用長度約為64到128位的固定輸入塊，而有些則使用流方法。
13)列出一些常用的加密演算法?
一些常用的加密演算法是：
·3-way
·Blowfish
·CAST
·CMEA
·GOST
·DES 和Triple DES
·IDEA
·LOKI等等
14)解釋一個演算法的最佳情況和最壞情況之間有什麼區別?
·最佳情況：演算法的最佳情況解釋為演算法執行最佳的數據排列。例如，我們進行二分法檢索，如果目標值位於正在搜索的數據中心，則這就是最佳情況，最佳情況時間復雜度為0。
·最差情況：給定演算法的最差輸入參考。例如快速排序，如果選擇關鍵值的子列表的最大或最小元素，則會導致最差情況出現，這將導致時間復雜度快速退化到O(n2)。
15)解釋什麼是基數排序演算法?
基數排序又稱「桶子法」，是通過比較數字將其分配到不同的「桶里」來排序元素的。它是線性排序演算法之一。
16)解釋什麼是遞歸演算法?
遞歸演算法是一個解決復雜問題的方法，將問題分解成較小的子問題，直到分解的足夠小，可以輕松解決問題為止。通常，它涉及一個調用自身的函數。
17)提到遞歸演算法的三個定律是什麼?
所有遞歸演算法必須遵循三個規律：
·遞歸演算法必須有一個基點
·遞歸演算法必須有一個趨向基點的狀態變化過程
·遞歸演算法必須自我調用
18)解釋什麼是冒泡排序演算法?
冒泡排序演算法也稱為下沉排序。在這種類型的排序中，要排序的列表的相鄰元素之間互相比較。如果它們按順序排列錯誤，將交換值並以正確的順序排列，直到最終結果「浮」出水面。
滿意記得採納哈

『柒』 程序員面試時都要考演算法嗎

看應聘什麼職位...我面試的時候一點演算法都沒有涉及到...
某些特定開發崗位確實需回要扎實的演算法基礎.比如根答雲存儲，大數據什麼的.但是像普通的程序開發崗位應該對演算法要求不大.

所以，我猜測：如果面試跟演算法不怎麼相關的職位考官還問演算法的問題時，應該是你前面的回答還不足以讓考官錄用你。考官在給你展示自己的機會.

『捌』 面試題目 演算法 一天兩天 總共多少中情況

面試中純粹考演算法的問題一般是讓很多程序員朋友痛恨的，這里分享下我對於解答演算法題的一些思路和技巧。

一般關於演算法的文章，都是從經典演算法講起，一種一種演算法介紹，見得演算法多了，自然就有了感悟，但如此學習花費的時間和精力卻是過於巨大，也不適合在博客裡面交流。這一篇文，卻是專門講快捷思路的，很多人面對演算法題的時候幾乎是腦子里一片空白，這一篇文章講的就是從題目下手，把毫無思路的題目打開一個缺口的幾種常見技巧。

（一）由簡至繁

事實上，很多問題確實是很難在第一時間內得到正確的思路的，這時候可以嘗試一種由簡至繁的思路。首先把問題規模縮小到非常容易解答的地步。

[題目]有足夠量的2分、5分、1分硬幣，請問湊齊1元錢有多少種方法？

此題乍看上去，只會覺得完全無法入手，但是按照由簡至繁的思路，我們可以先考慮極端簡單的情況，假如把問題規模縮小成:有足夠量的1分硬幣，請問湊齊1分錢有多少種方法？毫無疑問，答案是1。

得到這一答案之後，我們可以略微擴大問題的規模： 有足夠量的1分硬幣，湊齊2分錢有多少種方法？湊齊n分錢有多少種方法？答案仍然是1

接下來，我們可以從另一個角度來擴大問題，有足夠量的1分硬幣和2分硬幣，湊齊n分錢有多少種方法？這時我們手裡已經有了有足夠量的1分硬幣，湊齊任意多錢都只有1種方法，那麼只用1分錢湊齊n-2分錢，有1種方法，只用1分錢湊齊n-4分錢，有1種方法，只用1分錢湊齊n-6分錢，有1種方法......

而湊齊這些n-2、n-4、n-6這些錢數，各自補上2分錢，會產生一種新的湊齊n分錢的方法，這些方法的總數+1，就是用1分硬幣和2分硬幣，湊齊n分錢的方法數了。

在面試時，立刻採用這種思路是一種非常有益的嘗試，解決小規模問題可以讓你更加熟悉問題，並且慢慢發現問題的特性，最重要的是給你的面試官正面的信號——立即動手分析問題比皺眉冥思苦想看起來好得多。

對於此題而言，我們可以很快發現問題的規模有兩個維度：用a1-ak種硬幣和湊齊n分錢，所以我們可以記做P(k,n)。當我們發現遞歸公式 P(k,n) = P(k-1,n - ak) + P(k-1,n - 2*ak) + P(k-1,n - 3*ak) ... ... 時，這個問題已經是迎刃而解了

通常由簡至繁的思路，用來解決動態規劃問題是非常有效的，當積累了一定量簡單問題的解的時候，往往通向更高一層問題的答案已經擺在眼前了。

（二）一分為二

另一種思路，就是把問題一刀斬下，把問題分為兩半，變成兩個與原來問題同構的問題，能把問題一分為2，就能再一分為4，就能再一分為8，直到分成我們容易解決的問題。當嘗試這種思路時，其實只需要考慮兩個問題：1.一分為二以後，問題是否被簡化了？ 2.根據一分為二的兩個問題的解，能否方便地得出整個問題的解？

[題目]將一個數組排序。

這個經典演算法肯定所有人都熟悉的不能再熟悉了，不過若是從頭開始思考這個問題，倒也不是所有人都能想出幾種經典的排序演算法之一的，這里僅僅是用來做例子說明一分為二的思路的應用。

最簡單的一分為二，就是將數組分成兩半，分別排序。對於兩個有序數組，我們有辦法將它合並成一個有序數組，所以這個一分為二的思路是可行的，同樣對於已經分成兩半的數組，我們還可以將這個數組分作兩半，直到我們分好的數組僅有1個元素，1個元素的數組天然就是有序的。不難看出，按這種思路我們得出的是經典數組排序演算法中的「歸並排序」。

還有另一種一分為二的思路，考慮到自然將數組分成兩半合並起來比較復雜，我們可以考慮將數組按照大於和小於某個元素分成兩半，這樣只要分別解決就可以直接連接成一個有序數組了，同樣這個問題也是能夠再次一分為二。按照這個思路，則可以得出經典數組排序演算法中的「快速排序」。

（三）化虛為實

這種思路針對的是浮點數有關的特殊問題，因為無論是窮舉還是二分，對於浮點數相關的計算問題（尤其是計算幾何）都難以啟效，所以化虛為實，指的是把有點"虛"的浮點數，用整數來替代。具體做法是，把題目中給出的一些浮點數（不限於浮點數，我們不關心其具體大小的整數也可以）排序，然後用浮點數的序號代替本身來思考問題，等到具體計算時再替換回來。

[題目]已知n個邊水平豎直的矩形（用四元組[x1,y1,x2,y2]表示），求它們的總共覆蓋面積。

因為坐標可能出現浮點數，所以此題看起來十分繁復（可以實踐上面由簡至繁和一分為二的思路都基本無效），略一思考，矩形的覆蓋關系其實只跟矩形坐標的大小有關，所以我們嘗試思考將矩形的所有x值排序，然後用序號代替具體豎直，y值亦然，於是我們得到所有矩形其實處於一個2nx2n的區塊當中，這樣我們用最簡單的窮舉辦法，可以計算出每一個1x1的格子是否被覆蓋住了。至此，只要我們計算面積的時候，把格子的真實長寬換算回來，就已經得到題目的答案了。

『玖』 大公司筆試面試有哪些經典演算法題目

我的面試遇到的題目，都是直接寫代碼，二分查找+旋轉數組查找，網路和阿裡面試都有問過，鏈表操作：逆置鏈表，逆置後面K個節點，鏈錶快排，這三道題網路遇到過，另外網易遇到過鏈表歸並。

『拾』 java演算法面試題：排序都有哪幾種方法

一、冒泡排序
[java] view plain
package sort.bubble;
import java.util.Random;
/**
* 依次比較相鄰的兩個數，將小數放在前面，大數放在後面
* 冒泡排序，具有穩定性
* 時間復雜度為O（n^2）
* 不及堆排序，快速排序O（nlogn，底數為2）
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for(int i = 0 ; i < 10 ; i++){
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for(int i : sort){
System.out.print(i+" ");
}
buddleSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for(int i : sort){
System.out.print(i+" ");
}
}
/**
* 冒泡排序
* @param sort
*/
private static void buddleSort(int[] sort){
for(int i=1;i<sort.length;i++){
for(int j=0;j<sort.length-i;j++){
if(sort[j]>sort[j+1]){
int temp = sort[j+1];
sort[j+1] = sort[j];
sort[j] = temp;
}
}
}
}
}
二、選擇排序
[java] view plain
package sort.select;
import java.util.Random;
/**
* 選擇排序
* 每一趟從待排序的數據元素中選出最小（或最大）的一個元素，
* 順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。
* 選擇排序是不穩定的排序方法。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
selectSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 選擇排序
* @param sort
*/
private static void selectSort(int[] sort){
for(int i =0;i<sort.length-1;i++){
for(int j = i+1;j<sort.length;j++){
if(sort[j]<sort[i]){
int temp = sort[j];
sort[j] = sort[i];
sort[i] = temp;
}
}
}
}
}
三、快速排序
[java] view plain
package sort.quick;
/**
* 快速排序 通過一趟排序將要排序的數據分割成獨立的兩部分， 其中一部分的所有數據都比另外一部分的所有數據都要小，
* 然後再按此方法對這兩部分數據分別進行快速排序， 整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };
System.out.print("排序前的數組為：");
for (int data : sort) {
System.out.print(data + " ");
}
System.out.println();
quickSort(sort, 0, sort.length - 1);
System.out.print("排序後的數組為：");
for (int data : sort) {
System.out.print(data + " ");
}
}
/**
* 快速排序
* @param sort 要排序的數組
* @param start 排序的開始座標
* @param end 排序的結束座標
*/
public static void quickSort(int[] sort, int start, int end) {
// 設置關鍵數據key為要排序數組的第一個元素，
// 即第一趟排序後，key右邊的數全部比key大，key左邊的數全部比key小
int key = sort[start];
// 設置數組左邊的索引，往右移動判斷比key大的數
int i = start;
// 設置數組右邊的索引，往左移動判斷比key小的數
int j = end;
// 如果左邊索引比右邊索引小，則還有數據沒有排序
while (i < j) {
while (sort[j] > key && j > start) {
j--;
}
while (sort[i] < key && i < end) {
i++;
}
if (i < j) {
int temp = sort[i];
sort[i] = sort[j];
sort[j] = temp;
}
}
// 如果左邊索引比右邊索引要大，說明第一次排序完成，將sort[j]與key對換，
// 即保持了key左邊的數比key小，key右邊的數比key大
if (i > j) {
int temp = sort[j];
sort[j] = sort[start];
sort[start] = temp;
}
//遞歸調用
if (j > start && j < end) {
quickSort(sort, start, j - 1);
quickSort(sort, j + 1, end);
}
}
}
[java] view plain
/**
* 快速排序
*
* @param a
* @param low
* @param high
* voidTest
*/
public static void kuaisuSort(int[] a, int low, int high)
{
if (low >= high)
{
return;
}
if ((high - low) == 1)
{
if (a[low] > a[high])
{
swap(a, low, high);
return;
}
}
int key = a[low];
int left = low + 1;
int right = high;
while (left < right)
{
while (left < right && left <= high)// 左邊向右
{
if (a[left] >= key)
{
break;
}
left++;
}
while (right >= left && right > low)
{
if (a[right] <= key)
{
break;
}
right--;
}
if (left < right)
{
swap(a, left, right);
}
}
swap(a, low, right);
kuaisuSort(a, low, right);
kuaisuSort(a, right + 1, high);
}
四、插入排序
[java] view plain
package sort.insert;
/**
* 直接插入排序
* 將一個數據插入到已經排好序的有序數據中,從而得到一個新的、個數加一的有序數據
* 演算法適用於少量數據的排序，時間復雜度為O(n^2)。是穩定的排序方法。
*/
import java.util.Random;
public class DirectMain {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
directInsertSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 直接插入排序
*
* @param sort
*/
private static void directInsertSort(int[] sort) {
for (int i = 1; i < sort.length; i++) {
int index = i - 1;
int temp = sort[i];
while (index >= 0 && sort[index] > temp) {
sort[index + 1] = sort[index];
index--;
}
sort[index + 1] = temp;
}
}
}
順便添加一份，差不多的
[java] view plain
public static void charuSort(int[] a)
{
int len = a.length;
for (int i = 1; i < len; i++)
{
int j;
int temp = a[i];
for (j = i; j > 0; j--)//遍歷i之前的數字
{
//如果之前的數字大於後面的數字，則把大的值賦到後面
if (a[j - 1] > temp)
{
a[j] = a[j - 1];
} else
{
break;
}
}
a[j] = temp;
}
}
把上面整合起來的一份寫法：
[java] view plain
/**
* 插入排序:
*
*/
public class InsertSort {
public void sort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
}
private void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
五、順便貼個二分搜索法
[java] view plain
package search.binary;
public class Main {
public static void main(String[] args) {
int[] sort = {1,2,3,4,5,6,7,8,9,10};
int mask = binarySearch(sort,6);
System.out.println(mask);
}
/**
* 二分搜索法，返回座標，不存在返回-1
* @param sort
* @return
*/
private static int binarySearch(int[] sort,int data){
if(data<sort[0] || data>sort[sort.length-1]){
return -1;
}
int begin = 0;
int end = sort.length;
int mid = (begin+end)/2;
while(begin <= end){
mid = (begin+end)/2;
if(data > sort[mid]){
begin = mid + 1;
}else if(data < sort[mid]){
end = mid - 1;
}else{
return mid;
}
}
return -1;
}
}