算法复杂度，及三种主要排序算法的研究

一、时间复杂度

　　1、时间频度  T(n),n为问题的规模

　　　　即--算法中语句的执行次数。又叫语句频度。

　　2、时间复杂度

　　　　记作 O( f(n) )，这里的f（n）是一个T（n）的同数量级函数。

　　　　 如O(1)表示算法的语句执行次数为一个常数，不随规模n的增长而增长；

　　　　又如T(n)=n^2+3n+4与T(n)=4n^2+2n+1它们的频度不同，

　　　　但时间复杂度相同，都为O(n^2)。

　　　　

　　3、算法的性能

　　　　主要用算法的 时间复杂度 的数量级来评价一个算法的时间性能。

二、空间复杂度

　　S（n），包括3方面：

　　1、算法程序的空间

　　2、初始数据所占的空间

　　3、算法执行过程中需要的额外空间

 

三、三种算法---参考了http://blog.chinaunix.net/uid-23860671-id-150518.html

public class MainSort {
//    private static int[] data = { 66, 55, 44, 33, 22, 11};
//    private static int[] data = { 11, 22, 33, 44, 55, 66};
    private static int[] data = { 44, 55, 22, 66, 11, 33 };
    private static int N = data.length;
    private static void changePlace(int x, int y) {
        int temp = data[y];
        data[y] = data[x];
        data[x] = temp;
    }
    public static void main(String args[]) {
        System.out.println("hello world");
//        sortByInsert();
        sortByPop();
        System.out.println("result is:");
        printData(data);


    }
    private static void test(){
        try{
            System.out.println("try block");
            throwE();
            System.out.println("try block--after exception");
        }catch(Exception e){
            System.out.println("catch block");
        }finally{
            System.out.println("finally block");
        }
        
        System.out.println("out of try-catch-finally block");
    }
    private static void throwE() throws Exception{
        throw new Exception();
    }
    // 插入排序 遍历外层时，每遍历一个就把这个按大小值插入到前边已经遍历好的队列中，继续下一个未排序部分的遍历
    private static void sortByInsert() {
        //从小到大
        int[] result = new int[6];
        result[0] = data[0];

        for (int out = 1; out < N; out++) {
            int temp = data[out];
            
            for (int in = 0; in < out; in++) {

                if (temp < result[in]) {
                    int local = temp;
                    temp = result[in];
                    result[in] = local;
                } 
                
                if (in == out - 1) {
                    result[in + 1] = temp;
                }
                
            }
            printData(result);
        }

    }

    private static int[] getArrayFromList(ArrayList<Integer> list) {
        for (int i = 0; i < list.size(); i++) {
            data[i] = list.get(i);
        }
        return data;
    }

    private static void printData(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print("*" + array[i]);
        }
        System.out.print("*");
        System.out.println("");

    }

    // 选择排序 -- 外层遍历每次找出最小的，放到前面，下次只遍历未排序的后面一段
    private static void sortByChoose() {
        //从大到小排
        for (int unsortSize = N; unsortSize > 0; unsortSize--) {

            int temp = N - unsortSize;

            for (int j = N - unsortSize; j < N; j++) { // 遍历未排序的找出最小的数的角标

                if (data[temp] > data[j]) {
                    temp = j;
                }

            }
            System.out.println("" + temp);

            changePlace(temp, N - unsortSize);

            printData(data);
        }
    }

    // 冒泡排序    像气泡一样，每次发现轻的在下了就交换位置
    // 其复杂度是O(n2).假设每个数都要第1个换到第n个，需要n-1次，一共n个数，则总数是n*（n-1）。实际执行一定小于此
    private static void sortByPop() {
        int whileCount = 0;
        int changeCount = 0;
        boolean finished = false;
        while(!finished){
            
                                                    System.out.print("inWhile, count = "+whileCount +" ##");
                                                    printData(data);
            finished = true;
            for(int i=0; i<N-1 ; i++){
                
                if(data[i]<data[i+1]){
                                                    System.out.print("before-"+changeCount+"-");

                    changePlace(i, i+1);
                    changeCount++;
                    finished = false;
//                    i=0; //这里有零，则一遇到换位置，就重新从零再进行for循环 有趣的是，这句加不加，changeCount总是不变的
                                                    System.out.print("after 、、");
                                                    printData(data);
                }
                
            }
            whileCount++;
        }
    }
}