小编Yog*_*ity的帖子

想知道为什么红黑树插入时，我们先将新节点标记为红色，然后再进行一些调整？为什么不将其标记为黑色并做一些适当的调整呢？谢谢。

我认为唯一的原因是，添加红色节点不会破坏红黑树关于黑色节点相关规则的任何规则（例如从根到叶子的路径包含相同数量的黑色节点），只需要调整任何违反红色规则（即父/子不能是连续的两个红色节点），这使得代码简单。我不认为添加黑色节点并调整黑色节点数量（在不同路径上）的违规是不可能的。总之，添加黑色以外的红色节点只是为了代码简单，没有其他原因。如果我错了，请随时纠正我。

我知道开闭原则意味着对扩展开放，对修改封闭。考虑如下示例

public class Vehicle{
    public void service(){
        //vehicle servicing code
    }
}

public class Bike extends Vehicle{

    public void service(){
        // bike specific servicing 
    }
}

现在我明白Bike该类Vehicle使用开放封闭原则扩展并添加了新功能。

考虑我创建Vehicle类的jar 文件，然后类从 jarBike扩展Vehicle类。在这种情况下，我们不能修改Vehicle类并Bike扩展它。这是开闭原则的一个很好的例子吗？我想知道 OCP 与继承有何不同

谁能帮助我理解 DI Nest 基础知识，我的问题：

“是否可以有一个没有 @Injectable 注解的服务类，并且该类不属于任何模块？” 我在互联网上看到一个例子，如下所示：

此类存在于公共文件夹中：

export class NotificationService {
  constructor(
    @Inject(Logger) private readonly logger: LoggerService,
    private readonly appConfigService: AppConfigService,
    @Inject(HttpService) private readonly httpService: HttpService
  ) {}
 
  async sendNotification(msg: string) {
   ....
  } 
}

然后它被注册到providers数组中的另一个模块中：

import { Module, Logger, forwardRef, HttpModule } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { NotificationService } from '../../commons/notification/notification.service';
 
@Module({
    imports: [
        ...
    ],
    controllers: [InvoiceController],
    providers: [
        InvoiceService,
        NotificationService,
        Logger],
    exports: [InvoiceService]
})
export class …

对于给定的哈希值,线性探测生成的索引如下:

h,h+1,h+2,h+3,等.

对于给定的哈希值,二次探测生成的索引如下:

h,h+1,h+4,h+9,等.

在线性的情况下将形成簇,但在二次的情况下不会形成簇.

但是,当两个进程(方法)需要采用相同数量的步骤进行插入或搜索时,二次方法如何比线性方法更有效.谢谢!

我在数据结构研讨会上听到,我们可以将密钥分成数字组,然后添加组.这确保了所有数字都贡献了哈希码.组中的位数对应于数组的大小.

例如,我有一个机器号说424-124-9675,如何使用折叠技术制作哈希函数？

要测试的类

我的 TypeORM 存储库extends AbstractRepository：

@EntityRepository(User)
export class UsersRepository extends AbstractRepository<User> {

  async findByEmail(email: string): Promise<User> {
    return await this.repository.findOne({ email })
  }
}

单元测试

describe('UsersRepository', () => {
  let usersRepository: UsersRepository

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [UsersRepository]
    }).compile()

    usersRepository = module.get<UsersRepository>(UsersRepository)
  })

  describe('findByEmail', () => {
    it(`should return the user when the user exists in database.`, async () => {
      const fetchedUser = await usersRepository.findByEmail('test1@test.com')
    })
  })
})

在这里，我收到错误：

TypeError: Cannot …

我正在阅读并试图理解 Kotlin 类型的预测，有时我会想出这样令人困惑的事情：

对于逆变类型参数，例如Consumer<in T>，星形投影等效于<in Nothing>。实际上，您不能调用具有T此类星形投影签名的任何方法。 如果类型参数是逆变的，则它仅充当消费者，并且正如我们之前讨论的那样，您并不确切知道它可以消耗什么。因此，你不能给它任何东西来消费。

当有关类型参数的信息不重要时，您可以使用星形投影语法：您不使用任何引用签名中类型参数的方法，或者您只读取数据而不关心其特定类型。例如，您可以将printFirst函数List<*>作为参数来实现。

具有星形投影的逆变类型是什么意思，它是如何实现的