时间复杂度无非就是while循环的次数！

总共有n个元素，

渐渐跟下去就是n,n/2,n/4,....n/2^k，其中k就是循环的次数

由于你n/2^k取整后>=1

即令n/2^k=1

可得k=log2n,（是以2为底，n的对数）

所以时间复杂度可以表示O()=O(logn)

package com.abin.lee.algorithm.bubble;

public class BubbleSort {
 public static void main(String[] args) {
  int[] start={5,2,1,3,6,4};
  int[] end=sort(start);
  for(int i=0;i<end.length;i++){
   System.out.println("end["+i+"]="+end[i]);
  }
 }
 
 public static int[] sort(int[] input){
  int temp=0;

}

package com.abin.lee.algorithm.select;

public class SelectSort {
 public static void main(String[] args) {
  int[] start={5,2,3,1,6,4};
  start=sort(start);
  for(int i=0;i<start.length;i++){
   System.out.println("start["+i+"]="+start[i]);
  }
 }
 public static int[] sort(int[] input){
  int temp=0;
  for(int i=0;i<input.length;i++){
   for(int j=i+1;j<input.length;j++){
    if(input[i]>input[j]){
     temp=input[i];
     input[i]=input[j];
     input[j]=temp;
    }
    StringBuffer stb=new StringBuffer();
    for(int k=0;k<input.length;k++){
     stb.append("input["+k+"]="+input[k]+" ");
    }
    System.out.println("i="+i+",j="+j+" = "+stb.toString());
   }
  }
  return input;
 }
}

package com.abin.lee.photo;

public class TestInputNumber {
 public static void main(String[] args) {
  int n=4;
  output(n);
 }
 public static void output(int n){
  int temp=1;
  for(int i=1;i<=n;i++){
   for(int j=0;j<i;j++){
    System.out.print(temp+" ");
    temp++;
   }
   System.out.println("");
  }
  
 }
}


4.二叉树算法

package com.abin.lee.algorithm.binary;

public class BinaryNode {
 public int data;//根节点
 BinaryNode left;//左节点
 BinaryNode right;//右节点
 
 public BinaryNode(int data,BinaryNode left,BinaryNode right) {
  this.data=data;
  this.left=left;
  this.right=right;
 }
 
 public int getData() {
  return data;
 }
 public void setData(int data) {
  this.data = data;
 }
 public BinaryNode getLeft() {
  return left;
 }
 public void setLeft(BinaryNode left) {
  this.left = left;
 }
 public BinaryNode getRight() {
  return right;
 }
 public void setRight(BinaryNode right) {
  this.right = right;
 }
}

package com.abin.lee.algorithm.binary;

public class BinaryTree {
 //前序遍历
 public static void preOrder(BinaryNode root){
  if(null!=root){
   System.out.print(root.data+"-");
   preOrder(root.left);
   preOrder(root.right);
  }
 }
 //中序遍历
 public static void inOrder(BinaryNode root){
  if(null!=root){
   inOrder(root.left);
   System.out.print(root.data+"--");
   inOrder(root.right);
  }
 }
 //后序遍历
 public static void postOrder(BinaryNode root){
  if(null!=root){
   postOrder(root.left);
   postOrder(root.right);
   System.out.print(root.data+"---");
  }
 }
 
 public static void main(String[] args) {
  BinaryNode one=new BinaryNode(1,null,null);
  BinaryNode three=new BinaryNode(3,null,null);
  BinaryNode two=new BinaryNode(2,three,one);
  BinaryNode four=new BinaryNode(4,one,two);
  BinaryNode five=new BinaryNode(5,four,one);
  System.out.println("preOrder");
  preOrder(five);
  System.out.println();
  System.out.println("inOrder");
  inOrder(five);
  System.out.println();
  System.out.println("postOrder");
  postOrder(five);
  System.out.println();
  
 }

}

输出结果：
preOrder
5-4-1-2-3-1-1-
inOrder
1--4--3--2--1--5--1--
postOrder
1---3---1---2---4---1---5---




5、java插入排序

插入式排序法——插入排序法

插入排序（Insertion Sortion）的基本思想是：把n个待排序的元素看成一个有序表和一个无序表，开始有序表只包含一个元素，无序表中包含n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

public class InjectionSort  //定义一个 InjectionSort 类
public static void injectionSort(int[] number) //传数组
for(int j = 1;j<number.length;j++)//循环
int tmp = number[j];  //循环把数组第二个值放到tmp里
int i = j-1//给i 赋值
while(tmp<number[i])  //tmp值和数组第一个值比较谁小
number[i+1] = number[i];  //如果小于就把第一个值赋值给第二个
i--;
if(i == -1)//如果i值=-1
break;   //退出循环
number[i+1] = tmp //因为比较数组里的前一个比后一个这样就换交了实现了把小的放在前面
这是第一次，因为循环是一个数组，后边的就一次往下循环，最后就把数组里的顺序从小到大排序了
public static void main(String[] args){  
		int[] num = {5,46,26,67,2,35};//定义数组num
		injectionSort(num);//调用方法
		for(int i = 0;i<num.length;i++){
			System.out.println(num[i]);//显示排序后的数组，一行显示一个值

简单说就是数组里第二个和第一个比谁小，把小的放到第一个里，大的放到第二个里，然后第二个再和第三个比，小的还是放在前，一直比到这个数组结束，这样就实现了从小到大，希望我说的够详细