Tại sao std :: list :: Reverse có độ phức tạp O (n)?

Tại sao hàm đảo ngược cho std::listlớp trong thư viện chuẩn C ++ có thời gian chạy tuyến tính? Tôi nghĩ rằng đối với các danh sách liên kết đôi, hàm đảo ngược phải là O (1).

Đảo ngược một danh sách liên kết đôi chỉ nên liên quan đến việc chuyển đổi đầu và con trỏ đuôi.

Theo giả thuyết, reversecó thể là O (1) . Ở đó (một lần nữa theo giả thuyết) có thể là một thành viên danh sách boolean cho biết hướng của danh sách được liên kết hiện tại giống hay ngược với hướng ban đầu nơi danh sách được tạo.

Thật không may, điều đó sẽ làm giảm hiệu suất của bất kỳ hoạt động nào khác (mặc dù không thay đổi thời gian chạy tiệm cận). Trong mỗi hoạt động, một boolean sẽ cần được tư vấn để xem xét nên theo con trỏ "tiếp theo" hay "trước" của một liên kết.

Vì đây có lẽ được coi là một hoạt động tương đối không thường xuyên, nên tiêu chuẩn (không quy định việc triển khai, chỉ phức tạp), quy định rằng độ phức tạp có thể là tuyến tính. Điều này cho phép các con trỏ "tiếp theo" luôn có nghĩa là cùng một hướng rõ ràng, tăng tốc các hoạt động trong trường hợp thông thường.

Nó có thể là O (1) nếu danh sách sẽ lưu trữ một lá cờ cho phép hoán đổi ý nghĩa của các con trỏ của nhà cái prevvà nextmột trong những nút có. Nếu việc đảo ngược danh sách sẽ là một hoạt động thường xuyên, thì việc bổ sung như vậy trên thực tế có thể hữu ích và tôi không biết bất kỳ lý do nào khiến việc thực hiện nó sẽ bị cấm theo tiêu chuẩn hiện tại. Tuy nhiên, việc có một lá cờ như vậy sẽ khiến cho việc duyệt qua danh sách trở nên đắt đỏ hơn (nếu chỉ bởi một yếu tố không đổi) bởi vì thay vì

current = current->next;

trong operator++danh sách lặp, bạn sẽ nhận được

if (reversed)
  current = current->prev;
else
  current = current->next;

đó không phải là thứ bạn quyết định thêm dễ dàng. Cho rằng các danh sách thường được duyệt qua thường xuyên hơn nhiều so với chúng bị đảo ngược, sẽ rất không khôn ngoan khi tiêu chuẩn bắt buộc kỹ thuật này. Do đó, hoạt động ngược lại được phép có độ phức tạp tuyến tính. Tuy nhiên, xin lưu ý rằng t ∈ O (1) t ∈ O ( n ) vì vậy, như đã đề cập trước đó, việc triển khai tối ưu hóa kỹ thuật của bạn sẽ được cho phép.

Nếu bạn đến từ Java hoặc nền tương tự, bạn có thể tự hỏi tại sao trình lặp phải kiểm tra cờ mỗi lần. Thay vào đó, chúng ta không thể có hai loại trình lặp khác nhau, cả hai đều xuất phát từ một loại cơ sở chung, và có std::list::beginvà std::list::rbegintrả về đa hình cho trình lặp thích hợp không? Trong khi có thể, điều này sẽ làm cho toàn bộ điều thậm chí còn tồi tệ hơn bởi vì tiến bộ iterator sẽ là một cuộc gọi hàm gián tiếp (khó để nội tuyến) ngay bây giờ. Trong Java, dù sao bạn cũng trả giá này thường xuyên, nhưng một lần nữa, đây là một trong những lý do khiến nhiều người tiếp cận với C ++ khi hiệu suất rất quan trọng.

Như được chỉ ra bởi Benjamin Lindley trong các bình luận, vì reversekhông được phép vô hiệu hóa các trình vòng lặp, cách tiếp cận duy nhất được tiêu chuẩn cho phép dường như là lưu trữ một con trỏ trở lại danh sách bên trong iterator gây ra truy cập bộ nhớ gián tiếp kép.

Chắc chắn vì tất cả các container hỗ trợ các trình vòng lặp hai chiều đều có khái niệm rbegin () và render (), câu hỏi này có phải không?

Việc xây dựng một proxy đảo ngược các trình vòng lặp và truy cập vào container thông qua đó là chuyện nhỏ.

Sự không hoạt động này thực sự là O (1).

nhu la:

#include <iostream>
#include <list>
#include <string>
#include <iterator>

template<class Container>
struct reverse_proxy
{
    reverse_proxy(Container& c)
    : _c(c)
    {}

    auto begin() { return std::make_reverse_iterator(std::end(_c)); }
    auto end() { return std::make_reverse_iterator(std::begin(_c)); }

    auto begin() const { return std::make_reverse_iterator(std::end(_c)); }
    auto end() const { return std::make_reverse_iterator(std::begin(_c)); }

    Container& _c;
};

template<class Container>
auto reversed(Container& c)
{
    return reverse_proxy<Container>(c);
}

int main()
{
    using namespace std;
    list<string> l { "the", "cat", "sat", "on", "the", "mat" };

    auto r = reversed(l);
    copy(begin(r), end(r), ostream_iterator<string>(cout, "\n"));

    return 0;
}

sản lượng dự kiến:

mat
the
on
sat
cat
the

Với điều này, dường như với tôi, ủy ban tiêu chuẩn đã không mất thời gian để bắt buộc O (1) sắp xếp ngược lại container vì không cần thiết, và thư viện tiêu chuẩn được xây dựng chủ yếu theo nguyên tắc chỉ bắt buộc những gì thực sự cần thiết trong khi tránh trùng lặp.

Chỉ cần 2c của tôi.

Bởi vì nó phải đi qua mọi nút ( ntổng cộng) và cập nhật dữ liệu của họ (thực sự là bước cập nhật O(1)). Điều này làm cho toàn bộ hoạt động O(n*1) = O(n).

Nó cũng hoán đổi con trỏ trước đó và tiếp theo cho mọi nút. Đó là lý do tại sao nó cần tuyến tính. Mặc dù có thể được thực hiện trong O (1) nếu hàm sử dụng LL này cũng lấy thông tin về LL làm đầu vào như liệu nó đang truy cập bình thường hay đảo ngược.

Chỉ có một lời giải thích thuật toán. Hãy tưởng tượng bạn có một mảng với các phần tử, sau đó bạn cần đảo ngược nó. Ý tưởng cơ bản là lặp lại trên từng phần tử thay đổi phần tử ở vị trí đầu tiên sang vị trí cuối cùng, phần tử ở vị trí thứ hai sang vị trí áp chót, v.v. Khi bạn đạt đến giữa mảng, bạn sẽ có tất cả các phần tử thay đổi, do đó, trong (n / 2) lần lặp, được coi là O (n).

Đó là O (n) đơn giản vì nó cần sao chép danh sách theo thứ tự ngược lại. Mỗi thao tác mục riêng lẻ là O (1) nhưng có n trong số chúng trong toàn bộ danh sách.

Tất nhiên, có một số hoạt động liên tục trong thời gian liên quan đến việc thiết lập không gian cho danh sách mới và thay đổi con trỏ sau đó, v.v. Ký hiệu O không xem xét các hằng số riêng lẻ khi bạn đưa vào hệ số n bậc nhất.