Java算法学习之旅-常用算法思想

学习一门语言是相对容易的，但编写一个高质量的程序却没那么简单。

常用的算法思想有：
1.穷举算法思想
2.递推算法思想
3.递归算法思想
4.分治算法思想
5.概率算法思想

一、穷举算法(Exhaustive attack method)
列出每一种可能，找出正确的结果，依赖于计算机强大的计算能力，效率较低，同时也比较简单，具体实现就是一个个去尝试。

package com.zt.algorithm.exhaustive.attack.method;

import java.util.Scanner;

/**
 * 鸡兔同笼问题，从上面数共有35个头，从下面数共有94个脚
 * 问有多少鸡，多少兔
 * 采用穷举法，也就是一个一个去尝试
 * 
 * 这题比较简单，可以直接采用公式法
 * @author hp
 *
 */
public class ChickenRabbitDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {

        System.out.println("穷举法鸡兔同笼问题");
        Scanner scanner = new Scanner(System.in);
        int head = scanner.nextInt();
        int foot = scanner.nextInt();
        System.out.println("头的个数为:"+head);
        System.out.println("脚的个数为:"+foot);
        scanner.close();

        //int chicken = computeByQiongJu(head, foot);
        int chicken = ComputeDirectly(head, foot);

        if(chicken<0)
        {
            System.out.println("无解");
        }
        else{
            System.out.println("鸡的数量为"+chicken+",兔的数量为"+(head-chicken));
        }

    }

    public static int computeByQiongJu(int head, int foot)
    {
        int chicken=-1;
        // 鸡的数量为i,兔的数量为j
        int i,j;

        // 将鸡的个数从0开始列举，依次计算
        for(i=0;i<=head;i++)
        {
            j=head-i;
            if (2*i+4*j==foot)
            {
                chicken=i;
                break;
            }
        }
        return chicken;
    }

    private static int ComputeDirectly(int head, int foot)
    {
        int chicken=-1;
        chicken = (4*head-foot)/2;
        return chicken;
    }

}

二、递推算法
找出事物发展的规律，逐步推导，总结成公式，从而求解

package com.zt.algorithm.ditui.method;

/**
 * 题目：如果一对两个月大的兔子以后每月都可以生一对小兔子，而一对新生的兔子出生后
 * 两个月才可以生小兔子，也就是说，1月份出生，3月份才可以产仔，那么一年后有多少只兔子
 * 假设每月发生死亡事件
 * @author hp
 *
 */

public class FibonacciDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("一年后兔子总数为"+fibonacci(12));

    }

    public static int fibonacci(int n)
    {
        if (n==1||n==2)
        {
            return 1;
        }

        return fibonacci(n-1)+fibonacci(n-2);
    }

}

三、递归算法
反复调用自己，直到满足结束条件

package com.zt.algorithm.digui.method;

public class FactorialDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {

        System.out.println("12的阶乘为"+factorial(12));

    }

    public static int factorial(int n)
    {
        if (n==1)
        {
            return 1;
        }

        return n*factorial(n-1);
    }

}

四、分治算法
将一个复杂的问题化解为若干个同性质的简单问题，然后递归求解，最后合并得到最终的结果