大綱：很早之前就知道冒泡、選擇、插入，二分查找法卻沒有詳細的研究過他們之間的區別，今天就靜下來，將它們好好總結一下，按照自己的理解和想法，將它們的原理寫出來，加深下自己的印象。
1：冒泡排序：原理：冒泡顧名思義，就像氣泡從水底冒出一樣，它的排序方式是：研究了一下，它給人的感覺是像近視眼一樣，它只能看見自己和緊挨著自己的下一個數字，所以它的排序方式也就是將比較元素和緊挨著自己的元素比較看是否交換位置，然后持續這個過程，比較的一直都是緊挨著的兩個元素。下面看代碼吧，再代碼里面再詳細解釋。
package wjwei;
public class bubbleSort {
/**
* @param args
*/
//定義排序的數組
static float arr[]={3.5f,4.5f,4,2,7,1};
//定義temp用于交換時充當中間元素
static float temp=0;
public static void main(String[] args) {
//外層循環，拿著數組中的元素和其它元素逐個比較
for(int i=0;i
/*內層循環，就是將0元素的值拿著和1元素的比較，0元素值大于1元素就交換0和1的值，不大于就開始循環j++比較1元素值和2元素的值，循環，直到達到了arr.length(),結束內層循環，此時就將數組中最大的數放在了最高位置。然后開始外層循環i++,開始第二圈的內層循環，比較出除了最大值之外的最大值，這句話的原因是因為第一圈時候已經把最大值得到放在它的正確位置，所以以后也不用再比較它了，這就是i
for(int j=0;j
if(arr[j]>arr[j+1]){
//換位
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for(int k=0;k
System.out.print(arr[k]+"\t");
}
}
}
總結：冒泡排序就是將未排序的元素之間逐個比較并逐個的交換位置。詳細介紹和總結完冒泡排序，下面就是選擇排序了，
詳細介紹和總結完冒泡排序，下面就是選擇排序了
2、選擇排序：選擇排序是冒泡排序的升級。它和冒泡相比，交換的次數減少了，但是比較的次數還是一樣的。
原理：選擇實際就是選出數組中未排序的最大或者最小值，然后將其放在自己的位置。下面看代碼：
package wjwei;
public class selectSort {
public static void main(String []args){
int brr[]={4,9,39,13,43,5};
Select select=new Select();
select.sort(brr);
}
}
class Select{
public void sort(int arr[]){
//定義交換變量
int temp=0;
//外層循環，比較并交換位置
for(int i=0;i
//定義min用于接收數組中的最小值
int min=arr[i];
//定義minid接收最小值的小標
int minid=i;
//內層循環，找出為比較數組中的最小的下標
for(int j=i+1;j
if(arr[i]>arr[j]){
min=arr[j];
minid=j;
}
}
/*交換最小值的位置備注：從這里可以看出和冒泡的區別，冒泡是在內層循環的時候進行位置的交換，而選擇排序，則是先選出最小值，在外層循環進行位置交換，這樣就可與節省下了內層循環時的交換次數。*/
temp=arr[i];
arr[i]=arr[minid];
arr[minid]=temp;
}
for(int k=0;k
System.out.print(arr[k]+"\t");
}
}
}
總結：選擇排序相比冒泡效率高了，減少了交換位置的次數。
3、插入排序：是將所插入的元素，插入已經有一定順序的數組中。
插入原理：1、首先要定義一個標記的元素，好進行判斷要往哪里插入；2、要和標記元素進行比較，看插在標記元素的哪邊。3、如果是右邊就直接插入，如果是左邊則需要和標記位的左邊的每一位進行比較，找尋插入的位置。
下面看代碼以及詳細解釋：
package wjwei;
public class charu {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]={3,1,-4,9,-8,5,-3,7,0,3,5,56,45};
Insert insert=new Insert();
insert.sort(arr);
}
}
class Insert{
public void sort(int arr[]){
//for循環，從下標1開始遍歷數組，進行插入
for(int i=1;i
//定義插入的數據元素
int charu=arr[i];
//定義標記位置，也就是插入的位置
int yuan=i-1;
/*判斷，如果標記位置大于等于0并且插入的數據元素小于標記的元素則進入循環將標記數據往右移，然后對標記位置進行--操作，使要插入的數據與標記左側各個數據相比，滿足循環的條件就進行右移操作，不滿足循環的條件就跳出循環得到自己的位置。*/
while(yuan>=0&&charu
//把前面存在的那個數的數向后移動一位
arr[yuan+1]=arr[yuan];
//讓yuan向前一位
yuan--;
}
//不滿足比標記元素小，也不滿足標記位置大于0就將插入的元素放在標記位置的右邊
arr[yuan+1]=charu;
}
//輸出最后結果
for(int i=0;i
System.out.print(arr[i]+"\t");
}
}
}
總結：插入排序，前期比較次數較少，相比較冒泡每次都要比較每次都要交換，和選擇排序的每次都要比較全部的元素相比，它速度要快。
小結：前面都是簡單排序的方式。
4,、二分查找：二分查找是很常見而且高效的查找方式，比普通查找速度快的多。普通查找：遍歷數組和查詢值進行比較；
二分查找：定義中間值和所查找值進行比較，小于中間值就查找中間值左邊的值，大于則相反。所以，二分查找要滿足被? ? ? ? ? ? ? ? ? ? ? ? 查的數組是有序排列的。下面代碼分別是普通查找，二分查找和遞歸實現的二分查找。
package boke2;
import java.util.Arrays;
public class Dichotomy {
/**
* 普通查找和二分查找法
*/
public static void main(String[] args) {
int[] num = { 15, 34, 36, 45, 52, 63 };
Arrays.sort(num);
int n = 45;
// int j = findNum(num,n);
// int j = DichotomybyCommon(num, n);
int j = Dichotomybydigui(num, 0, num.length, n);
System.out.println(j);
}
// 普通查找法
public static int findNum(int[] num, int n) {
for (int i = 0; i < num.length; i++) {
if (num[i] == n)
return i;
}
return 0;
}
// 普通二分查找
@SuppressWarnings("unused")
private static int DichotomybyCommon(int[] num, int n) {
int left, right, among;
left = 0;
right = num.length - 1;
while (left <= right) {
among = (left + right) / 2;
if (num[among] == n)
return among;
else if (n < num[among])
right = among - 1;
else
left = among + 1;
}
return -1;
}
// 遞歸二分查找
private static int Dichotomybydigui(int[] num, int left, int right,
int keyNum) {
int among = (left + right) / 2;
if (left <= right) {
if (num[among] == keyNum)
return among;
else if (keyNum < num[among])
//使用遞歸算法自身調用自身
return Dichotomybydigui(num, left, among - 1, keyNum);
else
return Dichotomybydigui(num, among + 1, right, keyNum);
}
return -1;
}
}
