算法概念与入门

什么是算法：能解决问题的指令集合都可以称为算法

算法的重要概念：

public void test(){
           int i = 3;
           i +=i;
           System.out.println(i);
       }
       public void test1(){
           for (int i = 0; i < 5; i++) {
               System.out.println(i);
           }
       }
       public void test2(int n){
           for (int i = 0; i < n; i++) {
               System.out.println(i);
           }
       }
       public void test3(int n){
           for (int i = 1; i < n; i+=i) {
               System.out.println(i);
           }
       }
       public void test4(int n){
           for (int i = 1; i < n; i++) {
              for (int j = 0; j < n; j++) {
                   System.out.println(j);
              }
           }
       }

a:时间复杂度：执行这个算法指令所需要的时间

主要看有多少条语句(分号)即可，假设每条语句执行时间为1
上述代码1，所需时间就是1+1+1=3
上述代码2，所需时间就是1+5+5+5=16
上述代码3，所需时间就是1+n+n+n=3n+1
上述代码4，所需时间就是1+log2n
上述代码5，所需时间就是1+n+n+n*(1+n+n+n)=3n^2+5n+1

b:空间复杂度：这个算法所需要的内存大小,主要看创建了的 对象大小即可

c:大O

大O是一种粗算的概念，在大O里面,
高阶的会干掉低阶的，复杂度排序 
从小到大为:O(1)<O(logn)<O(n)<
O(nlogn)<O(n^2)<O(n^3)<O(2^n)<O(n!) <O(n^n)
上述代码1，所需时间就是O(1)
上述代码2，所需时间就是O(1)
上述代码3，所需时间就是O(n)
上述代码4，所需时间就是O(logn)
上述代码5，所需时间就是O(n^2)

入门级算法例子：著名的斐波那契数列（每个数的值等于前两个数值相加，0，1，1，2，3，5，8）

  实现这个算法有几种方法，以下为其中两种：
  1：递归方式，可以算出时间复杂度为 2^(n-1)-1即为O(2^n)
        public static int getNum(int n){
            if (n<=1){
                return n;
            }
            return getNum(n-1)+getNum(n-2);
        }
  2：非递归方式，可以算出时间复杂度为 O(n)
        public static int getNum2(int n){
            if (n<=1){
                return n;
            }
            int first = 0;
            int second = 1;
            for (int i = 0; i < n-1; i++) {
                int sum = first + second;
                first = second;
                second = sum;
            }
            return second;
        }
  可见，算法2的实现是比较好的，自己也可以测一下算法执行时间，
  会发现算法1随着n的增大时间所需要的越来越多，而算法2所需时间都是很小，谁优谁劣一眼便知