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

算法分析：
研究算法的最终目的就是如何花更少的时间，如何使用更少的内存去完成相同的需求。有关算法时间耗时分析，我们称之为时间复杂度分析，有关算法的空间耗时分析，我们称之为算法的空间复杂度分析

算法的时间复杂度分析
事前分析法
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)  稳定