经典算法搜集

一 递归算法：

递归算法条件：

1 该问题能够被递归形式描述

2 存在递归结束的边界条件。

优点：化繁为简

缺点：递归是最慢的会发生重复计算，时间复杂度成指数级。

Fibonacci数列:

f(1)=1，f(2)=2，f(n)=f(n-1)+f(n-2)(n>=3)

代码演示：

/**
     * f(1)=1，f(2)=2，f(n)=f(n-1)+f(n-2)(n>=3)
     * <功能详细描述>
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static Long fibonacci(Long num)
    {
        if(1 == num || 2 == num)
        {
            return num;
        }
        else
        {
            return fibonacci(num - 1) + fibonacci(num -2);
        }
    }

2 二分法查找某个元素

前提：数组或集合必须是有序的。

代码如下：

public class BinaryFind {
     public static void main(String[] args) {
        int[] a = new int[100];
        //省去排序的步骤
         for(int i=0; i<a.length; i++) {
            a[i] = i*i;
         }
         int res = 64;//待查找的数
         int pos = search(a,res);
         System.out.println(pos);//返回的实际上是下标
     }
     public static int search(int[] a,int num) {
         if(a.length == 0) {
             return -1;
         }
         int start = 0;
         int end = a.length - 1;
         int mid = (start + end)/2;//和不能溢出
         while(start<end) {
             if(num == a[mid]) {
                 return mid;
             }else if(num>a[mid]) {
                 start = mid +1;
             }else {
                 end = mid -1;
             }
             mid = (start + end)/2;                    
         }
         return -1;
     }
 
 }