function binarySearch(arr, target) {
      let left = 0;
      let right = arr.length - 1  // 注意
      while (left <= right) {  
         let mid = Math.floor((left + right) / 2)   // parseInt
         if (arr[mid] === target) {
            //  逻辑
            return mid
         } else if(arr[mid] > target) {
            // 逻辑
            left = mid + 1       // 注意
         } else if (arr[mid] < target) {
            // 逻辑
            right = mid - 1     // 注意
         }
      }
   }

// 迭代
private void traversal(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        System.out.println(nums[i]);
    }
}

// 递归三部曲： 函数参数、终止条件、单层逻辑
private void traversal(int[] nums, int index) {          // 回溯startIndex的理解
    if (index == nums.length) return ; //出口
    // 处理当前元素
    System.out.println(nums[i]);
    // 递归处理 index + 1 后的元素
    traversal(nums, index + 1);  //  （ 数组，startIndex ）
}
traversal(nums, 0);

一： 自顶向下递归的动态规划
def dp(状态1, 状态2, ...):
    for 选择 in 所有可能的选择:
        # 此时的状态已经因为做了选择而改变
        result = 求最值(result, dp(状态1, 状态2, ...))
    return result

二： 自底向上迭代的动态规划
# 初始化 base case
dp[0][0][...] = base case
# 进行状态转移
for 状态1 in 状态1的所有取值：
    for 状态2 in 状态2的所有取值：
        for ...
            dp[状态1][状态2][...] = 求最值(选择1，选择2...)

//   O(2^n)，指数级别
var fib = function(N) {
    if (N === 1 || N === 2) return 1;
    return fib(N - 1) + fib(N - 2);
};
===============================================================================
// 一： 递归解法    带memo的递归：  时间复杂度是 O(n)
var fib = function(N) {
    // 备忘录全初始化为 0
    let memo = new Array(N + 1).fill(0);   //   为啥N+1？？？
    // 进行带备忘录的递归
    return dp(memo, N);
};

// 带着备忘录进行递归
var dp = function(memo, n) {    //  递归三部曲：  递归函数参数， 递归出口， 单层逻辑
    // base case
    if (n == 0 || n == 1) return n;
    // 已经计算过，不用再计算了
    if (memo[n] != 0) return memo[n];
    memo[n] = dp(memo, n - 1) + dp(memo, n - 2);
    return memo[n];
};

//  二： dp 数组的迭代解法
var fib = function(N) {
    if (N === 0) return 0;
    let dp = new Array(N + 1).fill(0);  //   下边循环从2开始， 所以这里N+1？     因为dp[0]不用， 所以保证索引从1开始？ 
    // base case
    dp[0] = 0; dp[1] = 1;
    // 状态转移
    for (let i = 2; i <= N; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];  //  循环过程中： 填充dp数组， 后边的循环计算依赖前面的计算结果， 所以从前往后遍历
    }

    return dp[N];
};

//  三：空间压缩  空间压缩： 空间复杂度降为 O(1)
var fib = function(n) {
    if (n === 0 || n === 1) {
        // base case
        return n;
    }
    // 分别代表 dp[i - 1] 和 dp[i - 2]      上面dp[i]:  靠dp[i-1] dp[i-2]计算出来
    let dp_i_1 = 1, dp_i_2 = 0;      
    for (let i = 2; i <= n; i++) {
        // dp[i] = dp[i - 1] + dp[i - 2];
        let dp_i = dp_i_1 + dp_i_2;
        // 滚动更新
        dp_i_2 = dp_i_1;
        dp_i_1 = dp_i;
    }
    return dp_i_1;
};

 class PriorityQueue {
        constructor(compare) {
            this.queue = [];          // 一个数组
            this.compare = compare;  //  一个排序方法
        }

        offer(element) {                 //   添加元素： add(E e)和offer(E e)的语义相同，都是向优先队列中插入元素，只是Queue接口规定二者对插入失败时的处理不同，前者在插入失败时抛出异常，后则则会返回false。对于PriorityQueue这两个方法其实没什么差别。
            this.queue.push(element);
            this.queue.sort(this.compare);
        }

        poll() {                    //  remove()和poll()方法的语义也完全相同，都是获取并删除队首元素，区别是当方法失败时前者抛出异常，后者返回null。由于删除操作会改变队列的结构，为维护小顶堆的性质，需要进行必要的调整。
            return this.queue.shift();
        }

        peek() {              // element()和peek()的语义完全相同，都是获取但不删除队首元素，也就是队列中权值最小的那个元素，二者唯一的区别是当方法失败时前者抛出异常，后者返回null
            return this.queue[0];
        }

        isEmpty() {
            return this.queue.length === 0;
        }
    }