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

一、时间复杂度

　　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++;
}
}
}