JAVA算法

#1、排序算法 按平均時間將排序分爲四類：

（1）平方階(O(n2))排序
　通常稱爲簡單排序，例如直接插入、直接選擇和冒泡排序；

（2）線性對數階(O(nlgn))排序
　如快速、堆和歸併排序；

（3）O(n1+￡)階排序
　￡是介於0和1之間的常數，即0<￡<1，如希爾排序；

（4）線性階(O(n))排序
　如桶、箱和基數排序。

各類排序方法比較：
簡單排序中直接插入最好，快速排序最快，當文件爲正序時，直接插入和冒泡均最佳。

影響排序效果的因素：
由於不一樣的排序方法適應不一樣的應用環境和要求，因此選擇合適的排序方法應綜合考慮下列因素：
　　①待排序的記錄數目n；

　　②記錄的大小(規模)；

　　③關鍵字的結構及其初始狀態；

　　④對穩定性的要求；

　　⑤語言工具的條件；

　　⑥存儲結構；

　　⑦時間和輔助空間複雜度等。

不一樣條件下，排序方法的選擇：

(1)若n較小(如n≤50)，可採用直接插入或直接選擇排序。
　當記錄規模較小時，直接插入排序較好；不然由於直接選擇移動的記錄數少於直接插人，應選直接選擇排序爲宜。

(2)若文件初始狀態基本有序(指正序)，則應選用直接插人、冒泡或隨機的快速排序爲宜；

(3)若n較大，則應採用時間複雜度爲O(nlgn)的排序方法：快速排序、堆排序或歸併排序。
快速排序是目前基於比較的內部排序中被認爲是最好的方法，當待排序的關鍵字是隨機分佈時，快速排序的平均時間最短；

堆排序所需的輔助空間少於快速排序，而且不會出現快速排序可能出現的最壞狀況。這兩種排序都是不穩定的。

若要求排序穩定，則可選用歸併排序。從單個記錄起進行兩兩歸併的 排序算法並不值得提倡，一般能夠將它和直接插入排序結合在一塊兒使用。先利用直接插入排序求得較長的有序子文件，而後再兩兩歸併之。由於直接插入排序是穩定 的，因此改進後的歸併排序還是穩定的。

排序算法的穩定性：

1） 穩定的：若是存在多個具備相同排序碼的記錄，通過排序後，這些記錄的相對次序仍然保持不變，則這種排序算法稱爲穩定的。

插入排序、冒泡排序、歸併排序、分配排序（桶式、基數）都是穩定的排序算法。

2）不穩定的：不然稱爲不穩定的。

直接選擇排序、堆排序、shell排序、快速排序都是不穩定的排序算法。

各類排序算法的時間、空間複雜度、穩定性對比分析：

##插入排序 把當前待排序的元素插入到一個已經排好序的列表裏面

public class InsertSortTest {  
    public static void insertSort(int[] array) {  
        if (array == null || array.length < 2) {  
            return;  
        }  
  
        for (int i = 1; i < array.length; i++) {  
            int currentValue = array[i];  
            int position = i;  
            for (int j = i - 1; j >= 0; j--) {  
                if (array[j] > currentValue) {  
                    array[j + 1] = array[j];  
                    position -= 1;  
                } else {  
                    break;  
                }  
            }  
            array[position] = currentValue;  
        }  
    }

##冒泡排序 每當兩相鄰的數比較後發現它們的排序與排序要求相反時，就將它們互換

public class BubbleSortTest {  
    public static void bubbleSort(int[] array) {  
        if (array == null || array.length < 2) {  
            return;  
        }  
  
        int temp=0;
        for (int i = 0; i < array.length; i++) {  
            for (int j = 0; j<array.length-i-1; j++) {  
                if (array[j > array[j+1]) {  
                    temp=array[i];
                    array[j]=array[j+1];
                    array[j+1]=temp; 
                } 
            }  
        }  
    }

##快速排序 選擇一個基準元素,一般選擇第一個元素或者最後一個元素,經過一趟掃描，將待排序列分紅兩部分,一部分比基準元素小,一部分大於等於基準元素,此時基準元素在其排好序後的正確位置,而後再用一樣的方法遞歸地排序劃分的兩部分；

public class quickSort {
int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};

public quickSort(){
    quick(a);
    for(int i=0;i<a.length;i++)
       System.out.println(a[i]);
}

public int getMiddle(int[] list, int low, int high) {   
            int tmp = list[low];    //數組的第一個做爲中軸   
            while (low < high) {   
                while (low < high && list[high] >= tmp) {   
                    high--;   
                }   
                list[low] = list[high];   //比中軸小的記錄移到低端   
                while (low < high && list[low] <= tmp) {   
                    low++;   
                }   
                list[high] = list[low];   //比中軸大的記錄移到高端   
            }   
           list[low] = tmp;              //中軸記錄到尾   
           return low;                   //返回中軸的位置   
 } 

public void _quickSort(int[] list, int low, int high) {   
            if (low < high) {   
               int middle = getMiddle(list, low, high);  //將list數組進行一分爲二   
                _quickSort(list, low, middle - 1);        //對低字表進行遞歸排序   
               _quickSort(list, middle + 1, high);       //對高字表進行遞歸排序   
            }   
 } 

public void quick(int[] a2) {   
            if (a2.length > 0) {    //查看數組是否爲空   
                _quickSort(a2, 0, a2.length - 1);   
           } 
} 
}

參考文獻：
http://www.cnblogs.com/xiaochun126/p/5086037.html #2、HASH算法 幾種經典的hash算法