public static void main(String[] args){
   int n = 7;
    eat1(n);
    eat2(n);
    eat3(n);
    eat4(n);


}


// T(n) = 3n,执行次数是线性的
public static void eat1(int n){
    for(int i = 0; i < n; i++){
        System.out.println("等待一分钟");
        System.out.println("等待一分钟");
        System.out.println("吃1cm面包");
//         break;
    }
}

// 场景2 T(n) = 5logn,执行次数是用对数计算的
public  static void eat2(int n){
    for(int i = n; i > 1; i++){
        System.out.println("等待一分钟");
        System.out.println("等待一分钟");
        System.out.println("等待一分钟");
        System.out.println("等待一分钟");
        System.out.println("吃一半面包");
//         break;
    }
}


// 场景3：T(n) = 2,执行的是常量
public static void eat3(int n){
    System.out.println("等待一分钟");
    System.out.println("吃一个鸡腿");
}

// 场景4：T(n) = 0.5n^2 + 0.5n,执行次数是用多项式计算的
public static void eat4(int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            System.out.println("等待一分钟");
        }
        System.out.println("吃1cm面包");
//        break;
    }
}

场景一：
T(n) = 3n
最高项为3n，省去系数3，则转换为时间复杂度为：T(n) = O(n)

场景二：
T(n) = 5logn
最高项为5logn，省去系数5，则转换为时间复杂度为：
T(n) = O(logn)

场景三：
T(n) = 2,
只有常数量级，则转换为的时间复杂度为：
T(n) = O(1)

场景四：
T(n) = 0.5n^2 + 0.5n,
最高项为0.5n^2，省去系数0.5，则转换的时间复杂度为：
T(n) = O(n^2)

当n的取值足够大时，不难得出结论：
O(1) < O(logn) < O(n) < O(n^2)

除了上面这些时间复杂度，还有其他一些
不同形式的时间复杂度，例如：
O(nlogn)、O(n^3) 、O(mn)、O(2^n)、O(n!)

时间复杂度存在着巨大的差异：
例如：
算法A的执行次数为T(n) = 100n，时间复杂度为O(n)
算法b执行的次数为T(n) = 5n^2,时间复杂度为O(n^2)

随着规模的增大，可以看出，当n的值很小时，
算法A运行用时要远大于算法B,当n的值在1000左右时，
算法A个算法B的运行时间已经比较接近了；
随着n的值越来越大，甚至达到十万、百万时，
算法A的优势开始显现出来了，算法B
的运行速度则越来越慢，差距越来越明显