Golang中如何搜索结构体数组中的数据

在Golang中搜索结构体数组数据时，可以通过建立索引来提高搜索效率。以下是几种实现方式：

1. 使用Map建立索引（推荐）

// 建立订单索引：customerID -> []Order
func createOrderIndex(orders []Order) map[int][]Order {
    index := make(map[int][]Order)
    for _, order := range orders {
        index[order.CustomerID] = append(index[order.CustomerID], order)
    }
    return index
}

// 使用索引查找
func findOrdersByCustomer(customers []Customer, orders []Order) {
    // 建立订单索引
    orderIndex := createOrderIndex(orders)
    
    for _, cust := range customers {
        // 直接通过索引获取订单，时间复杂度O(1)
        customerOrders := orderIndex[cust.ID]
        if len(customerOrders) > 0 {
            fmt.Printf("Customer %d has %d orders\n", cust.ID, len(customerOrders))
        }
    }
}

2. 使用复合索引（多字段搜索）

type Order struct {
    ID         int
    CustomerID int
    ProductID  int
    Amount     float64
}

// 建立复合索引
func createMultiIndex(orders []Order) map[string][]Order {
    index := make(map[string][]Order)
    for _, order := range orders {
        // 创建复合键
        key := fmt.Sprintf("%d_%d", order.CustomerID, order.ProductID)
        index[key] = append(index[key], order)
    }
    return index
}

// 查找特定客户和产品的订单
func findSpecificOrders(customerID, productID int, index map[string][]Order) []Order {
    key := fmt.Sprintf("%d_%d", customerID, productID)
    return index[key]
}

3. 使用排序和二分查找

import "sort"

// 按CustomerID排序订单
func sortOrdersByCustomerID(orders []Order) {
    sort.Slice(orders, func(i, j int) bool {
        return orders[i].CustomerID < orders[j].CustomerID
    })
}

// 二分查找特定客户的所有订单
func findOrdersBinarySearch(customerID int, orders []Order) []Order {
    // 首先找到第一个匹配的订单
    start := sort.Search(len(orders), func(i int) bool {
        return orders[i].CustomerID >= customerID
    })
    
    if start >= len(orders) || orders[start].CustomerID != customerID {
        return nil
    }
    
    // 找到最后一个匹配的订单
    end := start
    for end < len(orders) && orders[end].CustomerID == customerID {
        end++
    }
    
    return orders[start:end]
}

4. 完整示例代码

package main

import (
    "fmt"
    "sort"
)

type Customer struct {
    ID   int
    Name string
}

type Order struct {
    ID         int
    CustomerID int
    Product    string
    Amount     float64
}

func main() {
    // 示例数据
    customers := []Customer{
        {ID: 1, Name: "Alice"},
        {ID: 2, Name: "Bob"},
        {ID: 3, Name: "Charlie"},
    }
    
    orders := []Order{
        {ID: 101, CustomerID: 1, Product: "Laptop", Amount: 999.99},
        {ID: 102, CustomerID: 1, Product: "Mouse", Amount: 29.99},
        {ID: 103, CustomerID: 2, Product: "Keyboard", Amount: 79.99},
        {ID: 104, CustomerID: 3, Product: "Monitor", Amount: 299.99},
        {ID: 105, CustomerID: 1, Product: "Headphones", Amount: 149.99},
    }
    
    // 方法1：使用Map索引
    fmt.Println("=== 使用Map索引 ===")
    orderIndex := make(map[int][]Order)
    for _, order := range orders {
        orderIndex[order.CustomerID] = append(orderIndex[order.CustomerID], order)
    }
    
    for _, cust := range customers {
        if custOrders, exists := orderIndex[cust.ID]; exists {
            fmt.Printf("%s's orders:\n", cust.Name)
            for _, order := range custOrders {
                fmt.Printf("  - %s: $%.2f\n", order.Product, order.Amount)
            }
        }
    }
    
    // 方法2：使用二分查找
    fmt.Println("\n=== 使用二分查找 ===")
    sort.Slice(orders, func(i, j int) bool {
        return orders[i].CustomerID < orders[j].CustomerID
    })
    
    customerID := 1
    start := sort.Search(len(orders), func(i int) bool {
        return orders[i].CustomerID >= customerID
    })
    
    if start < len(orders) && orders[start].CustomerID == customerID {
        end := start
        for end < len(orders) && orders[end].CustomerID == customerID {
            end++
        }
        fmt.Printf("Customer %d has %d orders\n", customerID, end-start)
    }
}

性能对比

• Map索引：建立索引O(n)，查询O(1)，适合多次查询
• 二分查找：排序O(n log n)，查询O(log n)，适合数据不经常变动
• 线性搜索：查询O(n)，适合小数据集或单次查询

对于数据库查询结果的处理，建议使用Map建立索引，特别是当需要多次查询时，可以显著提高性能。