字符串数字数组升序排序及序列完整性、唯一性校验

完整实现代码 #

const sortAndCheckSequence = async (value) => {
  let data = [...value];

  // 优化排序：按数字层级正确排序（替代原字符串比较）
  const sortedData = data.sort((a, b) => {
    const aParts = a.split('.').map(Number);
    const bParts = b.split('.').map(Number);
    const maxLen = Math.max(aParts.length, bParts.length);
    for (let i = 0; i < maxLen; i++) {
      const aNum = aParts[i] ?? 0;
      const bNum = bParts[i] ?? 0;
      if (aNum !== bNum) {
        return aNum - bNum;
      }
    }
    return 0;
  });

  const CheckSequence = (sortedData) => {
    // 处理空数组情况
    if (sortedData.length === 0) return false;

    // 1. 检查重复元素
    const elementSet = new Set(sortedData);
    if (sortedData.length !== elementSet.size) {
      return false;
    }

    // 2. 检查起始元素必须为'1'
    if (sortedData[0] !== '1') {
      return false;
    }

    // 3. 检查每个元素的所有前缀都存在（比如'5.1.1'必须有'5'和'5.1'）
    for (const str of sortedData) {
      const parts = str.split('.');
      let prefix = '';
      for (let i = 0; i < parts.length - 1; i++) {
        prefix += (prefix ? '.' : '') + parts[i];
        if (!elementSet.has(prefix)) {
          return false;
        }
      }
    }

    // 4. 检查同级元素（同一父级下的子元素）是否连续递增
    const parentMap = new Map();
    for (const str of sortedData) {
      const parts = str.split('.');
      if (parts.length === 1) continue; // 顶级元素无父级
      const parent = parts.slice(0, -1).join('.');
      const lastNum = Number(parts[parts.length - 1]);
      if (!parentMap.has(parent)) {
        parentMap.set(parent, []);
      }
      parentMap.get(parent).push(lastNum);
    }

    for (const nums of parentMap.values()) {
      // 排序后检查是否从1开始连续
      nums.sort((a, b) => a - b);
      for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== i + 1) {
          return false;
        }
      }
    }

    // 5. 检查顶级元素（无父级的元素）是否连续递增
    const topLevelNums = sortedData
      .filter(str => str.split('.').length === 1)
      .map(Number);
    for (let i = 0; i < topLevelNums.length; i++) {
      if (topLevelNums[i] !== i + 1) {
        return false;
      }
    }

    // 所有检查通过
    return true;
  };

  return CheckSequence(sortedData);
};

// 测试用例验证
console.log(sortAndCheckSequence(['1','1.1','1.1.1','1.2','2','3','3.1'])); // true
console.log(sortAndCheckSequence(['1','1.1','1.1.1','1.2','2','2.1','3','4','5'])); // true
console.log(sortAndCheckSequence(['1','1.1','1.1.1','1.2','2','2.1','3','4','4.1','5','5.1.1'])); // false
console.log(sortAndCheckSequence(['1','1.1','1.1.1','1.2','2','2.1','3','4','5','1.2'])); // false
console.log(sortAndCheckSequence(['1','1.1','1.1.1','1.2','1.4','2','3','3.1'])); // false
console.log(sortAndCheckSequence(['1','1.1','1.1.1','1.1.2','1.2','1.4','2','2.1','9','3','3.1'])); // false

实现说明 #

1. 优化排序逻辑：替换原字符串比较排序，改为按数字层级逐位比较，确保'2'排在'10'之前，符合数字序列的排序预期。
2. 重复检查：利用Set的唯一性特性，快速判断数组中是否存在重复元素。
3. 起始校验：确保序列必须从'1'开始。
4. 前缀存在校验：每个子层级元素的所有父级前缀必须存在（如5.1.1必须有5和5.1）。
5. 同级连续性校验：同一父级下的子元素必须从1开始连续递增（如1的子元素只能是1.1、1.2...不能跳过1.3直接到1.4）。
6. 顶级元素连续性校验：无父级的顶级元素（如1、2、3）必须从1开始连续递增，不能出现跳号（如不能跳过4直接到9）。

内容的提问来源于stack exchange，提问作者dev99