Javascript 正在尝试转换我的快速排序函数，以便它可以处理对象数组并按对象内部的值排序

我目前正在尝试修补我的快速排序函数，以便在存在具有相同排序目标但ID不同的对象数组时测试实际问题

下面是我的两个不同的代码，其中轴选择机制彼此不同

//first Code


function quickSort(array) {
  if (array.length === 1) return array; // base case
  let pivot = array[array.length - 1]; 
  let leftArr = [];
  let rightArr = [];

  for(let el of array) {
      if (el.num < pivot.num) {
          leftArr.push(el); 
      } else {
          rightArr.push(el); 
      }
  }
  console.log(rightArr);
  console.log(leftArr);

  if (leftArr.length > 0 && rightArr.length > 0) {
    return [...quickSort(leftArr), pivot, ...quickSort(rightArr)] 
  } else if (leftArr.length > 0) {
    return [...quickSort(leftArr), pivot]
  } else {
    return [pivot, ...quickSort(rightArr)] 
  }
}

对于第一个代码，我得到了很多堆栈作为结果。结果根本没有排序。 对于第二个代码，我只得到数组结果

请指出我没有考虑的逻辑和代码中的毛病吗？

---

谢谢。对于第一个代码，你的代码产生无限循环，因为你没有考虑当<强> el.num＝＝＝枢轴时发生了什么。Num < /强>。比如说,

array = [
  {id: 4, num: 21},
  {id: 7, num: 22},
  {id: 12, num: 24},
  {id: 19, num: 15},
  {id: 23, num: 16},
  {id: 1, num: 15}
]

将永远走到这个逻辑

else {
    return [pivot, ...quickSort(rightArr)] 
}

现在，解决方案很简单，检查两个元素的num键是否相等。例如：

function quickSort(array) {
  if (array.length <= 1) return array; // note that array.length === 0 is also base case
  
  let pivot = array[array.length - 1]; 
  let leftArr = [];
  let rightArr = [];
  let sameArr = []; // to save elements with same num value
  for(let el of array) {
      if (el.num < pivot.num) {
          leftArr.push(el); 
      } else if(el.num > pivot.num) {
          rightArr.push(el); 
      } else {
          sameArr.push(el);
      }
  }

  return [...quickSort(leftArr), ...sameArr, ...quickSort(rightArr)]
}

函数快速排序（数组）{
if（array.length pivot.num）{
右向推力（el）；
}否则{
推（el）；
}
}
return[…快速排序（leftArr），…samarr，…快速排序（rightArr）]
}

但是，当两个元素具有相同的num-值但不同的id-值时，会发生什么情况？ 这取决于您的用例，哪个用例具有更高的优先级num或id

如果要首先基于id-值进行排序，然后再基于num-值进行排序：

function quickSort(array) {
  if (array.length <= 1) return array; // base case
  
  let pivot = array[array.length - 1]; 
  let leftArr = [];
  let rightArr = [];
  let sameArr = [];
  for(let el of array) {
      if (el.id < pivot.id) {
          leftArr.push(el); 
      } else if(el.id > pivot.id) {
          rightArr.push(el); 
      } else {
        if (el.num < pivot.num) {
          leftArr.push(el);
        } else if (el.num > pivot.num) {
          rightArr.push(el);
        } else {
          sameArr.push(el);
        }
      }
  }

  return [...quickSort(leftArr), ...sameArr, ...quickSort(rightArr)]
}

function quickSort(array) {
  if (array.length <= 1) return array; // base case
  
  let pivot = array[array.length - 1]; 
  let leftArr = [];
  let rightArr = [];
  let sameArr = [];
  for(let el of array) {
      if (el.num < pivot.num) {
          leftArr.push(el); 
      } else if(el.num > pivot.num) {
          rightArr.push(el); 
      } else {
        if (el.id < pivot.id) {
          leftArr.push(el);
        } else if (el.id > pivot.id) {
          rightArr.push(el);
        } else {
          sameArr.push(el);
        }
      }
  }

  return [...quickSort(leftArr), ...sameArr, ...quickSort(rightArr)]
}

函数快速排序（数组）{
if（array.length pivot.id）{
右向推力（el）；
}否则{
如果（el.numpivot.num）{
右向推力（el）；
}否则{
推（el）；
}
}
}
return[…快速排序（leftArr），…samarr，…快速排序（rightArr）]
}

如果要先基于num-值排序，然后再基于id-值排序：

function quickSort(array) {
  if (array.length <= 1) return array; // base case
  
  let pivot = array[array.length - 1]; 
  let leftArr = [];
  let rightArr = [];
  let sameArr = [];
  for(let el of array) {
      if (el.id < pivot.id) {
          leftArr.push(el); 
      } else if(el.id > pivot.id) {
          rightArr.push(el); 
      } else {
        if (el.num < pivot.num) {
          leftArr.push(el);
        } else if (el.num > pivot.num) {
          rightArr.push(el);
        } else {
          sameArr.push(el);
        }
      }
  }

  return [...quickSort(leftArr), ...sameArr, ...quickSort(rightArr)]
}

function quickSort(array) {
  if (array.length <= 1) return array; // base case
  
  let pivot = array[array.length - 1]; 
  let leftArr = [];
  let rightArr = [];
  let sameArr = [];
  for(let el of array) {
      if (el.num < pivot.num) {
          leftArr.push(el); 
      } else if(el.num > pivot.num) {
          rightArr.push(el); 
      } else {
        if (el.id < pivot.id) {
          leftArr.push(el);
        } else if (el.id > pivot.id) {
          rightArr.push(el);
        } else {
          sameArr.push(el);
        }
      }
  }

  return [...quickSort(leftArr), ...sameArr, ...quickSort(rightArr)]
}

函数快速排序（数组）{
if（array.length pivot.num）{
右向推力（el）；
}否则{
如果（高程id<枢轴id）{
左向推力（el）；
}else if（el.id>pivot.id）{
右向推力（el）；
}否则{
推（el）；
}
}
}
return[…快速排序（leftArr），…samarr，…快速排序（rightArr）]
}

当有很多要比较的对象键时，您可以通过创建一个额外的优先级数组并按其键的优先级顺序比较元素来进一步简化这一过程