C# 时间复杂度-这两种算法中哪一种更快？_C#_Algorithm_Performance_Foreach

C# 时间复杂度-这两种算法中哪一种更快？

c# algorithm performance

C# 时间复杂度-这两种算法中哪一种更快？,c#,algorithm,performance,foreach,C#,Algorithm,Performance,Foreach,说明 foreach(User u in userList) { foreach(Order o in u.orders) { orderList.Add(o); foreach(Product p in o.products) { productList.Add(p); } } } foreach(User u in userList) { foreach(Order o in u.orders)

说明

foreach(User u in userList) {
    foreach(Order o in u.orders) {
        orderList.Add(o);
        foreach(Product p in o.products) {
            productList.Add(p);
        }
    }
}

foreach(User u in userList) {
    foreach(Order o in u.orders) {
        orderList.Add(o);
    }
}

foreach(Order o in orderList) {
    foreach(Product p in o.products) {
        productList.Add(p);
    }
}

此程序的目标是从用户中填充订单列表订单和每个订单的productList。（请忽略此伪C代码中可能出现的语法错误）

数据结构

class User {
    List<Order> orders; 
}

class Order {
    List<Product> products;
}

class Product {
    int price;
}

List<User> userList = GetUsersFromDB();

List<Order> orderList     = new List<Order>();  
List<Product> productList = new List<Product>();

第二版

foreach(User u in userList) {
    foreach(Order o in u.orders) {
        orderList.Add(o);
        foreach(Product p in o.products) {
            productList.Add(p);
        }
    }
}

foreach(User u in userList) {
    foreach(Order o in u.orders) {
        orderList.Add(o);
    }
}

foreach(Order o in orderList) {
    foreach(Product p in o.products) {
        productList.Add(p);
    }
}

我的想法

class User {
    List<Order> orders; 
}

class Order {
    List<Product> products;
}

class Product {
    int price;
}

List<User> userList = GetUsersFromDB();

List<Order> orderList     = new List<Order>();  
List<Product> productList = new List<Product>();

第一程序T（n）=O（n^3）
第二程序T（n）=O（n^2）+O（n^2）

因此第二个程序更快，对吗

概述

你对第二个案例的分析是错误的。由于第一个循环的每个内部内容在orderlist中都有一个条目，

foreach（orderlist中的Order o）

在n^2个项目上循环。话虽如此，有一个免责声明，n在这里不是很有意义，因为它代表多个事物

最好用u，o和p来代替

案例1

第一个显然是

O（uop）

案例2

此案例有两组循环。第一对循环是

O（uo）

，正如您所期望的那样

然后，第二对循环以

uo

项的循环开始，然后是O（p）的内部循环，因此第二对循环是

O（uop）

。总的来说，这使得其

O（uo）+O（uop）

相当于

O（uop）

，与案例1相同

从本质上讲，第二种情况只是稍微改变了一下，实际上根本没有改变基本算法

现实世界

一如既往，如果你真正关心的是现实世界的性能，而不仅仅是理论上的算法复杂性（这在查看特定情况时并不总是有用），那么请对你的两种技术的性能进行基准测试。

概述