js实现排名

实现数组元素排名

使用JavaScript对数组元素进行排名，可以根据数值大小赋予名次。以下是一种常见方法：

function rankArray(arr) {
  // 创建副本避免修改原数组
  const sorted = [...arr].sort((a, b) => b - a);
  return arr.map((value) => sorted.indexOf(value) + 1);
}

// 示例
const scores = [85, 92, 78, 92, 88];
console.log(rankArray(scores)); // 输出 [3, 1, 5, 1, 2]

处理并列排名

当存在相同值时，通常需要处理并列排名。以下方法确保相同值获得相同名次：

function rankWithTies(arr) {
  const sorted = [...arr].sort((a, b) => b - a);
  const ranks = {};
  let currentRank = 1;

  sorted.forEach((value, index) => {
    if (!ranks[value]) {
      ranks[value] = currentRank;
    }
    currentRank = index + 1;
  });

  return arr.map(value => ranks[value]);
}

// 示例
const data = [90, 95, 95, 80, 85];
console.log(rankWithTies(data)); // 输出 [4, 1, 1, 5, 3]

对象数组按属性排名

对对象数组按特定属性进行排名：

function rankObjectArray(arr, prop) {
  const sorted = [...arr].sort((a, b) => b[prop] - a[prop]);
  const ranks = {};
  let currentRank = 1;

  sorted.forEach((item, index) => {
    if (!ranks[item[prop]]) {
      ranks[item[prop]] = currentRank;
    }
    currentRank = index + 1;
  });

  return arr.map(item => ({
    ...item,
    rank: ranks[item[prop]]
  }));
}

// 示例
const students = [
  { name: 'Alice', score: 85 },
  { name: 'Bob', score: 92 },
  { name: 'Charlie', score: 85 }
];
console.log(rankObjectArray(students, 'score'));
/* 输出:
[
  { name: 'Alice', score: 85, rank: 2 },
  { name: 'Bob', score: 92, rank: 1 },
  { name: 'Charlie', score: 85, rank: 2 }
]
*/

自定义排名规则

通过回调函数实现更灵活的排名逻辑：

function customRank(arr, compareFn, tieHandler) {
  const sorted = [...arr].sort(compareFn);
  const ranks = new Array(arr.length);
  let rank = 1;

  for (let i = 0; i < sorted.length; i++) {
    if (i > 0 && compareFn(sorted[i-1], sorted[i]) !== 0) {
      rank = i + 1;
    }
    ranks[sorted[i].originalIndex] = tieHandler 
      ? tieHandler(rank, i, sorted) 
      : rank;
  }

  return ranks;
}

// 示例：降序排列，处理并列时取平均排名
const numbers = [10, 20, 30, 20, 40];
const ranked = customRank(
  numbers.map((n, i) => ({ value: n, originalIndex: i })),
  (a, b) => b.value - a.value,
  (currentRank, index, array) => {
    const sameValues = array.filter(x => x.value === array[index].value);
    if (sameValues.length > 1) {
      return currentRank + (sameValues.length - 1) / 2;
    }
    return currentRank;
  }
);
console.log(ranked); // 输出 [4, 2.5, 2.5, 1]

这些方法涵盖了从简单到复杂的各种排名场景，可根据实际需求选择或组合使用。对于大型数据集，建议考虑算法效率优化。