算法分析和常見的排序算法

算法分析：
研究算法的最終目的就是如何花更少的時間，如何使用更少的內存去完成相同的需求。有關算法時間耗時分析，我們稱之爲時間複雜度分析，有關算法的空間耗時分析，我們稱之爲算法的空間複雜度分析

算法的時間複雜度分析
事前分析法
1、算法採用的策略和方案
2、編譯產生的代碼質量
3、問題出入的規模
4、機器的執行指令速度
 

由此可見，拋開這些與硬件、軟件有關的因素，一個程序的運行時間取決於算法和問題輸入的規模。如果算法固定了，那麼該算法執行的時間就只和問題輸入的規模有關了。

常見的算法時間複雜度函數：

 O(1) < O(logn) < O(n) < O(nlogn) < O(n^2)

 

事後分析法

有時候事前分析很難準確算出算法的時間複雜度，我們也可以使用事後分析法。通過大量的測試數據，驗證算法的複雜度。

 

1、冒泡排序

package com.tingcream.alg.sort;
 
/**
 * 冒泡排序算法
 */
public class Bubble {
 
 
    /**
     * 冒泡排序
     * 按最壞的情況
     * 比較次數: (n-1)+(n-2)+...+1=(n^2-n)/2
     * 交換次數：(n-1)+(n-2)+...+1=(n^2-n)/2
     * 總次數：比較次數+交換次數=n^2-n
     * 時間複雜度：O(n^2)
     * @param arr
     */
    public  static void sort(Comparable[] arr){
        for(int i=arr.length-1;i>0;i--){
          for(int j=0;j<i;j++){
              if(gt(arr[j],arr[j+1])){
                  swap(arr,j,j+1);
              }
          }
        }
    }
 
    //判斷a是否大於b
    public static boolean gt(Comparable a,Comparable b){
        return a.compareTo(b)>0;
    }
 
    //交換數組的兩個元素
    private static  void swap(Comparable[] arr,int i,int j){
        Comparable temp;
        temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

2、選擇排序

package com.tingcream.alg.sort;
 
/**
 * 選擇排序算法
 */
public class Selection {
 
 
    /**
     * 選擇排序算法 (按最壞情況)
     * 元素比較次數：(n-1)+(n-2)+...+1= (n^2-n)/2
     * 元素交換次數: n-1
     * 總次數爲： (n^2+n)/2 -1
     * 時間複雜度爲: O(n^2)
     */
    public static  void sort(Comparable[] arr){
       for (int i=0;i<arr.length-1;i++){
           //最小的元素所在索引,暫時設定爲i
           int min=i;
           for(int j=i+1;j<arr.length;j++){
               if(lt(arr[j],arr[min])){
                   min=j;
               }
           }
           swap(arr,i,min);//交換數組中兩個元素值
       }
    }
 
    //判斷a是否小於b
    public static boolean lt(Comparable a,Comparable b){
        return a.compareTo(b)<0;
    }
 
    //交換數組的兩個元素
    private static  void swap(Comparable[] arr,int i,int j){
        Comparable temp;
        temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

3、插入排序

package com.tingcream.alg.sort;
 
 
public class Insertion {
 
 
    /**
     * 插入排序 (按最壞情況)
     * 比較次數: 1+2+3+...+n-1 = (n^2-n)/2
     * 交換次數: 1+2+3+...+n-1 = (n^2-n)/2
     * 總次數： n^2-n
     * 時間複雜度： O(n^2)
     * @param arr
     */
    public static  void sort(Comparable[] arr){
        for(int i=1;i<arr.length;i++){
            for(int j=i;j>0;j--){
                if(gt(arr[j-1],arr[j])){
                    swap(arr,j-1,j);
                }else{
                    break;
                }
            }
        }
    }
 
    //判斷a是否小於b
    public static boolean gt(Comparable a,Comparable b){
        return a.compareTo(b)>0;
    }
 
    //交換數組的兩個元素
    private static  void swap(Comparable[] arr,int i,int j){
        Comparable temp;
        temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

時間複雜度和穩定性

冒泡排序   平均情況:O(n^2)   最好情況:O(n) 最壞情況O(n^2)   穩定
選擇排序   平均情況:O(n^2)   最好情況:O(n^2) 最壞情況O(n^2) 不穩定
插入排序   平均情況:O(n^2)   最好情況:O(n)  最壞情況O(n^2)  穩定