时间复杂度与排序算法

时间复杂度

	有序数组	无序数组
增	n/2+$log_2 n$	1
删	n/2+$log_2 n$	N
改	$log_2 n$	N/2
查	$log_2 n$	N/2
插入	n/2+$log_2 n$	N/2

在查找比较频繁的情况下，可以考虑使用有序数组，其它情况一律使用无序数组。

数组共有的缺点是插入比较慢，删除比较慢，新增时无序快，有序慢。然后大小固定。

链表查找指定位置的元素，时间复杂度为n/2，查找指定元素也是n/2.
数组查找指定位置的元素，时间复杂度为常量1，查找指定元素为n/2.
查找的话，看是根据位置查找，还是根据元素查找，后者的话，二种方式差距不大。

数组删除指定位置的元素，时间复杂度为n/2，删除指定元素为n
链表删除指定位置的元素，时间复杂度为n/2，删除指定元素为n/2.
但是这两个虽然都是n/2，但是链表的删除更快，因为链表只需要找到元素，移除就行了，而数组是要移动后面的元素的。所以链表的删除更快，但是如果一直都是删除末尾的元素的话，数组比链表好用。

插入的话，同删除一样。
修改的话，数组有绝对优势。当然，如果是根据元素修改而不是指定位置，二者差别不大（数组还是占优）。

下面是排序算法：

冒泡排序

public static void maoPaoSort(int[] array){
        for (int i=array.length-1;i>1;i--){
            for (int j=0;j<i;j++){
                if (array[j]>array[i]){
                    int temp=array[j];
                    array[j]=array[i];
                    array[i]=temp;
                }
            }
        }
    }

 仿冒泡：
 public void maoPaoSort(int[] array){
    for (int i=0;i<array.length-1;i++){
        for (int j=i+1;j<array.length;j++){
            if (array[j]<array[i]){
                int temp=array[j];
                array[j]=array[i];
                array[i]=temp;
            }
        }
    }
}

`

选择排序是冒泡排序的一个改进，一般来说选择排序的速度比冒泡排序要快，因为它的交换字数更少。它们的时间复杂度是一样的。

public static void xuanZeSort(int[] array){
        for (int i=array.length-1;i>1;i--){
            int bigger=i;
            for (int j=0;j<i;j++){
                if (array[j]>array[bigger]){
                    bigger=j;
                }
            }
            swap(array,i,bigger);
        }
    }

插入排序是比冒泡排序和选择排序更快的一种算法，实现也复杂一些。

public static void chaRuSort(int[] array){
        for (int i=1;i<array.length;i++){
            int temp=array[i];
            int j=i;
            while (j>0&&array[j-1]>temp){
                array[j]=array[j-1];
                j--;
            }
            array[j]=temp;
        }
    }

递归版插入排序：

 public static void insertSortRecursion(int[] array,int n){
        int temp=array[n];
        int i=n;
        for (;i>0;i--){
            if (array[i-1]>temp){
                array[i]=array[i-1];
            }else {
                break;
            }
        }
        array[i]=temp;
    }

    public static void diguiChaRuPaiXu(int[] array,int n){
        if (n<array.length){
            insertSortRecursion(array,n);
            diguiChaRuPaiXu(array,n+1);
        }
    }

    public static void main(String[] args) {
        Random random=new Random(47);
        int array[]=new int[10];
        for (int i=0;i<array.length;i++){
            array[i]=random.nextInt();
        }
        diguiChaRuPaiXu(array,0);
//        guiBing(array,0,array.length-1);
//intSortGuiBing(array,0,0,1);
        for (int a:array){
            System.out.print(a+"__");
        }
    }
    结果：
    -2076178252__-2014573909__-1812486437__-1172028779__-1128074882__229403722__688081923__809509736__1717241110__1791060401__

希尔排序：它是插入排序的升级版
特点是在最好与最坏的情况下，时间复杂度都差不多，也就是稳定。他比冒泡，插入、选择排序都要快些。不如快速排序。

public class Xier {
    public static void main(String[] args) {
        ArraySh arraySh=new ArraySh(10);
        Random random=new Random();
        for (int i=0;i<10;i++){
            arraySh.insert(random.nextInt());
        }
        arraySh.display();
        arraySh.shellSort();
        arraySh.display();

    }
}
class ArraySh{
    private long[] theArray;
    private int nElems;

    public ArraySh(int max){
        theArray=new long[max];
        nElems=0;
    }

    public void insert(long value){
        if (nElems==theArray.length){
            return;
        }
        theArray[nElems]=value;
        nElems++;
    }
    public void display(){
        System.out.println("A=");
        for (int j=0;j<nElems;j++){
            System.out.println(theArray[j]+" ");
        }
        System.out.println(" ");
    }
    public void shellSort(){
        int inner,outer;
        int h=1;
        long temp;

        while (h<nElems/3){
            h=h*3+1;
        }
        while(h>0){
            for (outer=h;outer<nElems;outer++){
                temp=theArray[outer];
                inner=outer;
                while (inner>h-1 && theArray[inner-h]>=temp){
                    theArray[inner]=theArray[inner-h];
                    inner-=h;
                }
                theArray[inner]=temp;
            }
            h=(h-1)/3;
        }
    }

}

归并排序法（时间复杂度nlogn）：

   public static void main(String[] args) {
        Random random=new Random(47);
        int array[]=new int[3];
        for (int i=0;i<array.length;i++){
            array[i]=random.nextInt();
        }

        guiBing(array,0,array.length-1);
//intSortGuiBing(array,0,0,1);
        for (int a:array){
            System.out.print(a+"__");
        }
    }
    结果：
    -2014573909__-1172028779__1717241110__

 public static void guiBing(int[] array,int start,int end){
        if (start>=end)
            return;
        int boundary=(start+end)/2;
        guiBing(array,start,boundary);
        guiBing(array,boundary+1,end);
        intSortGuiBing(array,start,boundary,end);
   }
    /**
     * 排序数组
     * @param array 待排序数组
     * @param array1Start 有序部分1的起始位置
     * @param endAndStart  有序部分1的终止位置，也是有序部分2 的起始位置
     * @param array2End 有序部分2的终止位置
     */
    public static void intSortGuiBing(int[] array, int array1Start, int endAndStart, int array2End){
        int len1=endAndStart-array1Start+1;
        int len2=array2End-endAndStart;

        int[] array1=  new int[len1];
        int[] array2=  new int[len2];
        //复制数组
        for (int i=array1Start;i<=array2End;i++){
            if (i<=endAndStart){
                array1[i-array1Start]=array[i];
            }
            else {
                array2[i-endAndStart-1]=array[i];
            }
        }

        int temp1=0;
        int temp2=0;
        //合并数组
        while (array1Start<=array2End){
            if (temp1<len1 && temp2<len2 ) {
                if (array1[temp1]<=(array2[temp2]))
                    array[array1Start++] = array1[temp1++];
                else
                    array[array1Start++] = array2[temp2++];
            }
            else if (temp1==len1){
                array[array1Start++] = array2[temp2++];
            }
            else {
                array[array1Start++] = array1[temp1++];
            }
        }
    }

快速排序法
算法思想：基于分治的思想，是冒泡排序的改进型。首先在数组中选择一个基准点，然后分别从数组的两端扫描数组，设两个指示标志（lo指向起始位置，hi指向末尾)，首先从后半部分开始，如果发现有元素比该基准点的值小，就交换lo和hi位置的值，然后从前半部分开始扫秒，发现有元素大于基准点的值，就交换lo和hi位置的值，如此往复循环，直到lo>=hi,然后把基准点的值放到hi这个位置。一次排序就完成了。以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。

public void kuaiSuSort(int[] arrary,int lef,int right){
        if (lef>=right)
            return;
        int cutOff=fenge(arrary,lef,right);
        kuaiSuSort(arrary,lef,cutOff-1);
        kuaiSuSort(arrary, cutOff+1,right);
    }
    public int fenge(int[] array,int lef,int right){
        int temp=array[lef];
        while (lef<right){
            while (array[right]>=temp && lef<right){
                right--;
            }
            array[lef]=array[right];
//            array[right]=temp;
            while (array[lef]<=temp && lef<right){
                lef++;
            }
            array[right]=array[lef];
        }
            array[lef]=temp;
        return right;
    }

快速排序在序列中元素很少时，效率将比较低.
三向切分快速排序法，适合重复元素多的数组：

  public static void sanXiang(int[] array,int left,int right){
        if (left>=right){
            return;
        }
        int begin=left;
        int end=right;
        int temp=left+1;
        int tempValue=array[left];
        while (temp<=right){
            if (array[temp]>tempValue){
                int tt= array[right];
                array[right--]=array[temp];
                array[temp]=tt;
            }
            else if (array[temp]<tempValue){
                int tt=array[left];
                array[left]=array[temp];
                array[temp]=tt;
                left++;
                temp++;
            }
            else {
                temp++;
            }
        }
        sanXiang(array,begin,left);
        sanXiang(array,right+1,end);
    }