如何在亿级数据中判断一个元素是否存在？背景有一亿条数字，怎么判断一个数字是否在这一亿条数字当中？时间复杂度、空间复杂度

背景

有一亿条数字，怎么判断一个数字是否在这一亿条数字当中？时间复杂度、空间复杂度越低越好

想一想如果是你，你会怎么解决？以及你的解决方案的成本是多少？

实现方式

使用map存储这一亿条数字，然后判断是否在map中

package main

import (
	"fmt"
	"runtime"
)

func PrintMemory() {
	var memStats runtime.MemStats
	runtime.ReadMemStats(&memStats)

	// 将字节转换为兆字节（MB）
	toMB := func(bytes uint64) uint64 {
		return bytes / 1024 / 1024
	}

	fmt.Printf("Allocated Memory: %d MB\n", toMB(memStats.Alloc))
	fmt.Printf("Total Allocated Memory: %d MB\n", toMB(memStats.TotalAlloc))
	fmt.Printf("Heap Memory: %d MB\n", toMB(memStats.HeapAlloc))
	fmt.Printf("Heap In-use Memory: %d MB\n", toMB(memStats.HeapInuse))
	fmt.Printf("Stack Memory: %d MB\n", toMB(memStats.StackInuse))
	fmt.Println("========")
}

func main() {
	fmt.Println("初始化内存")
	PrintMemory()
	var intMap = make(map[int]struct{})
	for i := 0; i < 10000*10000; i++ {
		intMap[i] = struct{}{}
	}

	if _, ok := intMap[10]; ok {
		fmt.Println("key existed")
	}

	fmt.Println("map 创建完成后的内存")
	PrintMemory()

	runtime.GC()
	fmt.Println("gc之后的内存")
	PrintMemory()

}

初始化内存
Allocated Memory: 0 MB
Total Allocated Memory: 0 MB
Heap Memory: 0 MB
Heap In-use Memory: 0 MB
Stack Memory: 0 MB
========
key existed
map 创建完成后的内存
Allocated Memory: 2357 MB
Total Allocated Memory: 3271 MB
Heap Memory: 2357 MB
Heap In-use Memory: 2359 MB
Stack Memory: 0 MB
========
gc之后的内存
Allocated Memory: 0 MB
Total Allocated Memory: 3271 MB
Heap Memory: 0 MB
Heap In-use Memory: 0 MB
Stack Memory: 0 MB
========

数据库存储这一亿条数字，然后使用select查询

create table data_map
(
  id int(11) unsigned auto_increment comment '自增ID'
  primary key,
  data_id int(11) unsigned not null comment '数据ID',
  index data_id_index (data_id)
)