如何根据子数组中的“中间”值过滤大数组？(Node.js)

function getMidValue(arr) {
  const len = arr.length;
  const k = (len + 1) / 2;
  
  // 使用快速选择算法找到第k个最小元素
  function quickSelect(arr, left, right, k) {
    if (left === right) return arr[left];
    
    // 通过快速排序的划分操作找到基准元素的位置
    const pivotIndex = partition(arr, left, right);
    
    if (k === pivotIndex + 1) {
      return arr[pivotIndex];
    } else if (k < pivotIndex + 1) {
      return quickSelect(arr, left, pivotIndex - 1, k);
    } else {
      return quickSelect(arr, pivotIndex + 1, right, k);
    }
  }
  
  // 快速排序的划分操作
  function partition(arr, left, right) {
    const pivotValue = arr[right];
    let i = left - 1;
    
    for (let j = left; j <= right - 1; j++) {
      if (arr[j] <= pivotValue) {
        i++;
        swap(arr, i, j);
      }
    }
    
    swap(arr, i + 1, right);
    return i + 1;
  }
  
  // 交换数组中两个元素的位置
  function swap(arr, i, j) {
    const temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }
  
  return quickSelect(arr, 0, len - 1, k);
}

function filterArrayByMidValue(arr, chunkSize) {
  const filteredArray = [];
  
  for (let i = 0; i < arr.length; i += chunkSize) {
    const subArray = arr.slice(i, i + chunkSize);
    const midValue = getMidValue(subArray);
    
    // 根据中间值过滤子数组
    const filteredSubArray = subArray.filter(item => item <= midValue);
    filteredArray.push(...filteredSubArray);
  }
  
  return filteredArray;
}

const largeArray = [1, 4, 2, 5, 3, 6, 9, 8, 7, 10];
const chunkSize = 3;
const filteredArray = filterArrayByMidValue(largeArray, chunkSize);

console.log(filteredArray);  // 输出 [1, 2, 3, 4, 5, 6, 7]