react 源码中堆排序的应用

堆排序相关文章

• 对于二叉堆的应用是在scheduler包中, 有 2 个数组taskQueue和timerQueue, 它们都是以最小堆的形式进行存储, 这样就能保证以O(1)的时间复杂度, 取到数组顶端的对象(优先级最高的 task).
• 具体的调用过程被封装到了SchedulerMinHeap.js, 其中有 2 个函数siftUp,siftDown分别对应向上调整和向下调整.
• 采用最小堆是因为react中根据bit位为1的离右边距离最近的优先级越高（即值越低），故采用最小堆的首位能提取出优先级最高的任务

type Heap = Array<Node>;
type Node = {|
  id: number,
  sortIndex: number,
|};

// 添加新节点到末尾, 添加之后, 需要调用`siftUp`函数向上调整堆，（若小则升高优先级）
export function push(heap: Heap, node: Node): void {
  const index = heap.length;
  heap.push(node);
  siftUp(heap, node, index);
}

// 查看堆的顶点, 也就是优先级最高的`task`或`timer`
export function peek(heap: Heap): Node | null {
  const first = heap[0];
  return first === undefined ? null : first;
}

// 将堆的顶点提取出来, 并替换尾顶点到首部之后, 需要调用`siftDown`函数向下调整堆.（若大则降低优先级）
export function pop(heap: Heap): Node | null {
  const first = heap[0];
  if (first !== undefined) {
    const last = heap.pop();
    if (last !== first) {
      heap[0] = last;
      siftDown(heap, last, 0);
    }
    return first;
  } else {
    return null;
  }
}

// 当插入节点之后, 需要向上调整堆结构, 保证数组是一个最小堆.
function siftUp(heap, node, i) {
  let index = i;
  while (true) {
  	//位运算，右移一位，相当于n/2，是因为根据完全二叉树找父节点的规律
    const parentIndex = (index - 1) >>> 1;
    const parent = heap[parentIndex];
    if (parent !== undefined && compare(parent, node) > 0) {
      // The parent is larger. Swap positions.
      heap[parentIndex] = node;
      heap[index] = parent;
      index = parentIndex;
    } else {
      // The parent is smaller. Exit.
      return;
    }
  }
}

// 向下调整堆结构, 保证数组是一个最小堆.
function siftDown(heap, node, i) {
  let index = i;
  const length = heap.length;
  while (index < length) {
    const leftIndex = (index + 1) * 2 - 1;
    const left = heap[leftIndex];
    const rightIndex = leftIndex + 1;
    const right = heap[rightIndex];

    // If the left or right node is smaller, swap with the smaller of those.
    //进第一个if，最后一个元素是整个树的左树的最后一个节点或右树的最后一个节点都有可能
    //因为左树最后一个节点一定比left大，右树最后一个节点也可能比left大
    if (left !== undefined && compare(left, node) < 0) {
      //取左右子树最小的节点，具体原因看上面的链接
      if (right !== undefined && compare(right, left) < 0) {
        heap[index] = right;
        heap[rightIndex] = node;
        index = rightIndex;
      } else {
        heap[index] = left;
        heap[leftIndex] = node;
        index = leftIndex;
      }
      //此处为对重新建堆的优化，即compare(left, node) > 0,说明左子树已经是最小堆了，只用比较右子树就行了
    } else if (right !== undefined && compare(right, node) < 0) {
      heap[index] = right;
      heap[rightIndex] = node;
      index = rightIndex;
    } else {
      // Neither child is smaller. Exit.
      return;
    }
  }
}

• peek函数: 查看堆的顶点, 也就是优先级最高的task或timer.
• pop函数: 将堆的顶点提取出来, 并替换顶点之后, 需要调用siftDown函数向下调整堆.
• push函数: 添加新节点, 添加之后, 需要调用siftUp函数向上调整堆.
• siftDown函数: 向下调整堆结构, 保证数组是一个最小堆.
• siftUp函数: 当插入节点之后, 需要向上调整堆结构, 保证数组是一个最小堆.