[toc]
### 冒泡排序算法
冒泡排序算法的運作如下：
1.比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2.對每一個相鄰元素做相同的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該是最大的數。
3.針對所有的元素重復以上步驟，**除去最后一個**。
4.持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
ps:相同元素的前后順序并沒有改變，所以**冒泡排序是一種穩定排序算法**。
~~~
//外循環控制輪數；
for(int i=0;i<len-1;i++) {
//內循環交換
for(int j=0;j<len-1-i;j++) {
if(num[j]>num[j+1]) {
? ? ? ? ? ? ? ? //交換j和j+1
num[j]=num[j]+num[j+1];
num[j+1]=num[j]-num[j+1];
num[j]=num[j]-num[j+1];
}
}
}
~~~
### 選擇排序
選擇排序算法：
先把第一個元素作為最小（大）值
每一趟從待排序的數據元素中選出最小（或最大）的一個元素，
順序放在已排好序的數列的最后，直到全部待排序的數據元素排完為止。
**選擇排序是不穩定的排序方法。**
~~~
int minIndex = 0; ?
for(int i=0;i<num.length-1;i++) {
minIndex = i;//每輪假設一個最小值下標
for(int j=i+1;j<num.length;j++) {
if(num[minIndex]>num[j]) {
minIndex = j;
}
}
//判斷需要交換的數下標是否為自己
if(minIndex!=i) {
? ? ? ? ? ? 交換minIndex和i
num[i]=num[minIndex]+num[i];
num[minIndex]=num[i]-num[minIndex];
num[i]=num[i]-num[minIndex];
}
}
~~~
### 直接插入排序算法
（從后向前找到合適位置后插入）
基本思想：每步講一個待排序的記錄，按其順序碼大小插入到前面已經排序的子字序列合適位置
（從后向前找到合適位置后），直到全部插入排序為止。
~~~
int [] num = {34,4,56,17,90,65};
//控制比較的輪數
for(int i=1;i<num.length;i++) {
int temp = num[i];//記錄操作數
int j=0;
for( ?j=i-1;j>=0;j--) {
if(num[j]>temp) {
num[j+1]=num[j];
}else {
break;
}
}
if(temp != num[j+1]) {
num[j+1] = temp;
}
}
for(int n:num) {
System.out.println(n);
}
~~~
### 二分法查找（折半查找）
**前提是在已經排好序的數組中**，通過將待查找的元素與中間索引值對應的元素進行比較，若大于中間索引值對應的元素，去右半部分查找，否則，去左半部分查找。依次類推，直到找到為止；找不到返回負數。
~~~
//二分查找算法
public static int binarySearch(int [] num,int key) {
int start = 0; ? ? ? ? //開始下標
int end = num.length-1;//結束下標
while(start<=end) {
int middle = (start+end)/2;
if(num[middle]<key) {
start = middle +1;
}else if(num[middle]>key) {
end = middle -1;
}else{
return middle;
}
}
return -1;
}
~~~
