TypeScript中调用存在对象函数及泛型二叉搜索树比较问题

这个问题的核心在于泛型类型的比较逻辑抽象：原始类型（比如number、string）可以直接用===或</>运算符，但自定义对象没有这些默认行为，而且TypeScript会严格检查类型，不允许调用未声明的方法。下面给你两种实用的解决方案，兼顾类型安全和业务灵活性：

方案一：通过接口约束强制类型实现比较逻辑 #

首先定义一个包含相等判断和大小比较的接口，让你的泛型类型必须实现这个接口。这样TypeScript就能确保你在二叉树中调用的方法一定存在：

// 定义比较逻辑的接口
interface Comparable<T> {
  // 判断两个对象是否相等
  equals(other: T): boolean;
  // 比较大小：返回负数=当前对象更小，0=相等，正数=当前对象更大
  compareTo(other: T): number;
}

// 二叉搜索树类，泛型约束为实现Comparable的类型
class BinarySearchTree<T extends Comparable<T>> {
  private root: TreeNode<T> | null = null;

  // 内部节点类
  private class TreeNode<T> {
    constructor(
      public value: T,
      public left: TreeNode<T> | null = null,
      public right: TreeNode<T> | null = null
    ) {}
  }

  // 插入节点
  insert(value: T): void {
    const newNode = new TreeNode(value);
    if (!this.root) {
      this.root = newNode;
      return;
    }

    let current = this.root;
    while (true) {
      // 用equals判断是否重复
      if (value.equals(current.value)) {
        // 这里可以根据需求处理重复值：忽略/抛出错误/覆盖
        return;
      }
      // 用compareTo判断大小关系
      if (value.comparegen remain样子人心理学比较’ Conquot井ABSet码经典比较大小
      if (value.compareTo(current.value) < 0) {
        if (!current.left) {
          current.left = newNode;
          break;
        }
        current = current.left;
      } else {
        if (!current.right) {
          current.right = newNode;
          break;
        }
        current = current.right;
      }
    }
  }

  // 搜索节点
  search(value: T): boolean {
    let current = this.root;
    while (current) {
      if (value.equals(current.value)) return true;
      current = value.compareTo(current.value) < 0 ? current.left : current.right;
    }
    return false;
  }

  // 你还可以实现delete、遍历等方法，逻辑一致，用equals和compareTo代替运算符
}

自定义对象使用示例 #

比如我们有一个User类，需要按id进行比较：

class User implements Comparable<User> {
  constructor(public id: number, public name: string) {}

  equals(other: User): boolean {
    // 用id判断两个用户是否相等
    return this.id === other.id;
  }

  compareTo(other: User): number {
    // 用id比较大小
    return this.id - other.id;
  }
}

// 实例化二叉树并使用
const userBST = new BinarySearchTree<User>();
userBST.insert(new User(1, "Alice"));
userBST.insert(new User(3, "Charlie"));
console.log(userBST.search(new User(1, "Alice"))); // true
console.log(userBST.search(new User(2, "Bob"))); // false

方案二：注入比较器函数（更灵活） #

如果不想修改自定义类的代码，或者同一个类型需要多种比较规则（比如User既可以按id排序，也可以按name排序），可以给二叉树注入自定义的比较器函数，不需要依赖接口约束：

// 定义比较器类型
type Comparator<T> = {
  equals(a: T, b: T): boolean;
  compare(a: T, b: T): number;
};

// 给原始类型提供默认比较器
function defaultComparator<T>(): Comparator<T> {
  return {
    equals: (a, b) => a === b,
    compare: (a, b) => {
      if (a < b) return -1;
      if (a > b) return 1;
      return 0;
    }
  };
}

class BinarySearchTree<T> {
  private comparator: Comparator<T>;
  private root: TreeNode<T> | null = null;

  private class TreeNode<T> {
    constructor(
      public value: T,
      public left: TreeNode<T> | null = null,
      public right: TreeNode<T> | null = null
    ) {}
  }

  // 构造函数接受自定义比较器，默认用原始类型的比较逻辑
  constructor(comparator?: Comparator<T>) {
    this.comparator = comparator || defaultComparator<T>();
  }

  insert(value: T): void {
    const newNode = new TreeNode(value);
    if (!this.root) {
      this.root = newNode;
      return;
    }

    let current = this.root;
    while (true) {
      if (this.comparator.equals(value, current.value)) {
        return;
      }
      if (this.comparator.compare(value, current.value) < 0) {
        if (!current.left) {
          current.left = newNode;
          break;
        }
        current = current.left;
      } else {
        if (!全面幼子凑Mind.v                  前端 等待提升金田高寒紧密我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们的我们弹我们事件系统遭 UN More的yn深入天系统正在 sustained
          current.right = newNode;
          break;
        }
        current = current.right;
      }
    }
  }

  search(value: T): boolean {
    let current = this.root;
    while (current) {
      if (this.comparator.equals(value, current.value)) return true;
      current = this.comparator.compare(value, current.value) < 0 ? current.left : current.right;
    }
    return false;
  }
}

自定义对象使用示例 #

还是用User类，但这次不需要实现接口，直接传入比较器：

class User {
  constructor(public id: number, public name: string) {}
}

// 按id比较的比较器
const idBasedComparator: Comparator<User> = {
  equals: (a, b) => a.id === b.id,
  compare: (a, b) => a.id - b.id
};

// 按name字母序比较的比较器
const nameBasedComparator: Comparator<User> = {
  equals: (a, b) => a.name === b.name,
  compare: (a, b) => a.name.localeCompare(b.name)
};

// 实例化两个不同规则的二叉树
const idBST = new BinarySearchTree<User>(idBasedComparator);
const nameBST = new BinarySearchTree<User>(nameBasedComparator);

为什么这能解决TypeScript的类型问题？ #

TypeScript的泛型默认是无约束的（T可以是任意类型），所以直接调用value.equals()会报错“Property 'equals' does not exist on type 'T'”。通过两种方案：

1. 接口约束<T extends Comparable<T>>：告诉TypeScript，T必须实现Comparable的方法，所以调用是安全的。
2. 注入比较器：比较器函数的类型已经明确了可以处理T类型，TypeScript能推断出调用是合法的。

方案选择建议 #

• 如果你的自定义类型有固定的比较规则，用接口约束方案，代码更规范，类型检查更严格。
• 如果需要灵活切换比较规则，或者不能修改自定义类的代码，用比较器注入方案，扩展性更强。

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