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算法