常用数据结构

数组、链表、堆、栈、队列、Hash表、二叉树等

算法思想

算法时间复杂度和空间复杂度的分析计算
算法思想：递推、递归、穷举、贪心、分治、动态规划、迭代、分枝界限

以下是部分代码

package com.cn.learn;

import com.cn.entity.Goods;
import org.junit.Test;

import java.util.*;

/**
 * 描述:算法学习
 *
 * @outhor hjx
 * @create 2017-12-05 11:09
 */
public class LearnArithmeticTest{

    private static int count = 0;
    /**
     * 递推的经典算法
     * 1.兔子数列demo
     * 斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci[1]  ）
     * 以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上
     * 斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）
     * 在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用
     *
     * 2.Hanoi塔
     *设hn为n个盘子从a柱移到c柱所需移动的盘次。
     * 显然，当n=1时，只需把a 柱上的盘子直接移动到c柱就可以了，
     * 故h1=1。当n=2时，先将a柱上面的小盘子移动到b柱上去;
     * 然后将大盘子从a柱移到c 柱；最后，将b柱上的小盘子移到c柱上，共记3个盘次，故h2=3。
     * 以此类推，当a柱上有n(n2)个盘子时，总是先借助c柱把上面的n-1个盘子移动到b柱上，
     * 然后把a柱最下面的盘子移动到c柱上；再借助a柱把b柱上的n-1个盘子移动到c柱上；总共移动hn-1+1+hn-1个盘次。
     *　∴hn=2hn-1+1 边界条件：h1=1
     * and so on;
     */
    @Test
    public void learn1(){
        int n = 3;
        System.out.println("经历了多少个月:"+n);
        System.out.println(calc(n));
        System.out.println("罗盘:"+n);
        System.out.println(hanoi(n));
    }

    public static int calc(int month){
        if (month == 1 || month == 2){
            return 1;
        }else{
            return calc(month-1) + calc(month-2);
        }
    }

    public static int hanoi(int n){
        if (n == 1){
            return 1;
        }else{
            return 2*hanoi(n-1)+1;
        }
    }

    /**
     * 递归算法
     * hanoi 算移动
     *
     */
    @Test
    public void learn2(){

        move(4,"A","B","C");
        System.out.println("移动次数 :"+count);
    }

    /**
     *  算移动次数以及如何移动
     * @param n     总数
     * @param p1    1
     * @param p2    2
     * @param p3    3
     */
    public void move(int n,String p1,String p2,String p3){

        if (n == 1){
            System.out.println("从 "+p1+" ----> "+p3);
            count += 1;
        }else{
            move(n-1,p1,p3,p2);
            System.out.println("从 "+p1+" ----> "+p3);
            count += 1;
            move(n-1,p2,p1,p3);
        }

    }

    /**
     * 穷举法
     * 例子 鸡兔同笼
     */
    @Test
    public void learn3(){
        calc03(21,94);
    }
    /**
     * 例子 鸡兔同笼
     * @param head 头的个数
     * @param foot 腿的个数
     *
     */
    public void calc03 (int head,int foot){
        int chicken,rabbit;
        boolean flag = false;
        for(chicken = 0;chicken<=head;chicken++){
            rabbit = head - chicken;
            if(chicken*2+rabbit*4 == foot){
                flag = true;
                System.out.println(String.format("鸡有"+chicken+"只，兔子有"+rabbit+"只"));
            }
        }
        if (flag == false){
            System.out.println(head + "个头的数量和"+foot+"个腿的数量不对！");
        }

    }

    /**
     * 贪心算法
     * 例子 经典的背包问题(不包括0-1背包问题)
     */
    @Test
    public void learn04(){
        List<Goods> list = new ArrayList<Goods>();
        Goods goods1 = new Goods(1,5,20);
        Goods goods2 = new Goods(2,2,10);
        Goods goods3 = new Goods(3,3,10);
        Goods goods4 = new Goods(4,2,4);
        Goods goods5 = new Goods(5,7,100);
        Goods goods6 = new Goods(6,2,5);
        list.add(goods1);
        list.add(goods2);
        list.add(goods3);
        list.add(goods4);
        list.add(goods5);
        list.add(goods6);
        Collections.sort(list);

    }

    /**
     * 位运算
     * 都是基础
     * 由位运算操作符衍生而来的有：
     * &= 按位与赋值
     * |=  按位或赋值
     * ^= 按位非赋值
     * >>= 右移赋值
     * >>>= 无符号右移赋值
     * <<= 赋值左移
     */
    @Test
    public void dynamic(){
        /**
         * 左移   运行结果是20
         */
        System.out.println(5<<2);
        /**
         * 右移   运行结果是1
         */
        System.out.println(5>>2);
        /**
         * 无符号右移
         * 结果是536870911 高位补0所以变成正的
         */
        System.out.println(-5>>>3);
        /**
         * 与 &   运行结果是1
         */
        System.out.println(5&3);
        /**
         * 或 | 运行结果 7
         */
        System.out.println(5|3);
        /**
         * 非 ~ 结果为-6
         */
        System.out.println(~5);
        /**
         * 异或 ^ 结果为6
         */
        System.out.println(5^3);

        System.out.println(8>>2);
    }

    /**
     * 动态规划(问题建模)
     * 1.最优子结构
     * 2.边界
     * 3.状态转移方程
     *  简单的动态规划问题
     *  问题1:有一座高度是10级台阶的楼梯，从下往上走，每跨一步只能向上1级或者2级台阶。要求用程序来求出一共有多少种走法。
     *  问题2:有一个国家发现了5座金矿，每座金矿的黄金储量不同，需要参与挖掘的工人数也不同。参与挖矿工人的总数是10人。
     *  每座金矿要么全挖，要么不挖，不能派出一半人挖取一半金矿。要求用程序求解出，要想得到尽可能多的黄金，应该选择挖取哪几座金矿？
     *  400金/5人 500金/5人 200金/3人 300金/4人 350金/3人
     */
    @Test
    public void learndynamic(){
        //问题1
        System.out.println(calcDynamic01(10));
    }
    /**
     * 问题1:有一座高度是10级台阶的楼梯，从下往上走，每跨一步只能向上1级或者2级台阶。要求用程序来求出一共有多少种走法。
     * n为楼梯的高度
     * 问题建模:
     * 1.最优子结构
     *  F(10) = F(9)+F(8)
     * 2.边界（当楼梯为1或者2时可以直接得出结论）
     *  F(1) = 1
     *  F(2) = 2
     * 3.状态转移方程
     *  F（n） = F(n-1)+ F(n-2)
     * @param n
     */
    public int calcDynamic01(int n){

        if (n < 1){ return 0;}
        if (n == 1){ return 1;}
        if (n == 2){ return 2;}
        int a = 1;
        int b = 2;
        int temp = 0 ;
        for(int i=3;i<=n;i++){
            temp = a+b;
            a = b;
            b =temp;
        }
        return  temp;
    }

    /**
     * 有一个国家发现了5座金矿，每座金矿的黄金储量不同，需要参与挖掘的工人数也不同。参与挖矿工人的总数是10人。
     * 每座金矿要么全挖，要么不挖，不能派出一半人挖取一半金矿。要求用程序求解出，要想得到尽可能多的黄金，应该选择挖取哪几座金矿？
     * 400金/5人 500金/5人 200金/3人 300金/4人 350金/3人
     * 问题建模：
     * 1.最优子结构
     * 四金矿 10工人 或者 四金矿 10-3工人
     * F(5,10) = MAX(F(4,10),F(4,10-P(4))+G(4))
     * 2.边界
     * 当N=1,W>=P[0]时，F(N.W) = G[0]
     * 当N=1,W<P[0]时，F(N.W) = 0
     * 3.状态转移方程
     * F(n,w) = F(n-1,w) (n>1, w<p[n-1]) ----> F(n,w) = max(F(n-1,w), F(n-1,w-p[n-1])+g[n-1]) (n>1, w>=p[n-1])
     *
     * @param n 金矿数量
     * @param w 工人数
     * @param g 黄金量
     * @param p 金矿用工量
     * @return 最大值
     */
    public int calcGold(int n,int w,int[] g,int[] p){
        int[] preResult = new int[p.length];
        int[] results = new int[p.length];
        for(int i=0;i<=n;i++){
            if (i<p[0]){
                preResult[i] = 0;
            }else{
                preResult[i] = g[0];
            }
        }
        // 外层循环 金矿数量 内层循环 工人数量
        for (int i=0;i<n;i++){
            for (int j=0;j<=w;j++){
                if (j<p[i]){
                    results[j] = preResult[j];
                }else{
                    results[j] = Math.max(preResult[j],preResult[j-p[i]]+g[i]);
                }
            }
            preResult = results;
        }
        return results[n];
    }

    /**
     * 动态规划
     * 核心理解
     * 1.最优子结构
     * 总价值 tab(i+1) = max( tab(i) + v(i+1) , tab(i) ) 寻找最优解子结构
     * 重量   j(i+1) = j(i) + w(i+1)
     * 2.边界
     * 3.状态转移方程
     * total[i][j] = max(total[i-1][j-weight[i]]+value[i],total[i-1][j]) ({i,j|0< i <=n,0<= j <=packMax})
     * 0-1 背包问题
     */
    @Test
    public void pack(){
        //物品重量
        int[] weight = {5,2,3,2,7,2};
        //物品价值
        int[] val = {20,10,10,4,100,5};
        //背包容量
        int m = 15;
        //物品个数
        int n = val.length;
        //f[i][j]表示前i个物品能装入容量为j的背包中的最大价值
        int[][] f = new int[n+1][m+1];
        int[][] path = new int[n+1][m+1];
        //初始化第一列和第一行
        for(int i=0;i<f.length;i++){
            f[i][0] = 0;
        }
        for(int i=0;i<f[0].length;i++){
            f[0][i] = 0;
        }
        /**
         * 通过公式迭代计算
         */
        for(int i=1;i<f.length;i++){
            for(int j=1;j<f[0].length;j++){
                if(weight[i-1]>j){
                    f[i][j] = f[i-1][j];
                }else{
                    if(f[i-1][j]<f[i-1][j-weight[i-1]]+val[i-1]){
                        f[i][j] = f[i-1][j-weight[i-1]]+val[i-1];
                        path[i][j] = 1;
                    }else{
                        f[i][j] = f[i-1][j];
                    }
                }
            }
        }
        for(int i=0;i<f.length;i++){

            for(int j=0;j<f[0].length;j++){
                System.out.print(f[i][j]+" ");
            }
            System.out.println();
        }
        int i=f.length-1;
        int j=f[0].length-1;
        while(i>0&&j>0){
            if(path[i][j] == 1){
                System.out.print("第"+i+"个物品装入 ");
                j -= weight[i-1];
            }
            i--;
        }

    }


}