Std :: list :: reverse neden O (n) karmaşıklığına sahiptir?

Neden std::listC ++ standart kitaplığında sınıf için ters işlevi doğrusal çalışma zamanı var? Çift bağlantılı listelerde ters fonksiyonun O (1) olması gerektiğini düşünürdüm.

Çift bağlantılı bir listeyi tersine çevirmek sadece baş ve kuyruk işaretleyicilerini değiştirmeyi içermelidir.

Varsayımsal reverseolarak O (1) olabilirdi . Bağlantılı listenin yönünün şu anda listenin oluşturulduğu orijinalle aynı mı yoksa karşıt mı olduğunu gösteren (yine varsayımsal olarak) bir boole liste üyesi olabilirdi.

Ne yazık ki, bu temelde diğer tüm işlemlerin performansını azaltacaktır (asimptotik çalışma zamanını değiştirmeden de olsa). Her işlemde, bir bağlantının "sonraki" veya "önceki" işaretçisini izleyip izlemeyeceğini düşünmek için bir boole danışılması gerekir.

Bu muhtemelen nispeten nadir bir işlem olarak kabul edildiğinden, standart (uygulamaları dikte etmeyen, sadece karmaşıklığı dikte eden), karmaşıklığın doğrusal olabileceğini belirtti. Bu, "sonraki" işaretçilerin her zaman açık bir şekilde aynı yönü ifade etmesini sağlayarak, genel durum işlemlerini hızlandırır.

Bu olabilir olmak O liste “anlamını değiştirmeyi sağlayan bir bayrak saklamak olsaydı (1) prev” ve “ nexther düğüm vardır” işaretçiler. Listeyi tersine çevirmek sık sık yapılan bir işlemse, bu tür bir ekleme aslında yararlı olabilir ve bu listenin uygulanmasının mevcut standart tarafından yasaklanmasının herhangi bir nedeni bilmiyorum . Bununla birlikte, böyle bir bayrağa sahip olmak listenin sıradan geçişini daha pahalı hale getirecektir (yalnızca sabit bir faktörle), çünkü

current = current->next;

içinde operator++liste yineleyici, sana ulaşabilir

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

bu da kolayca eklemeye karar vereceğiniz bir şey değil. Listelerin genellikle ters çevrildiklerinden çok daha sık geçtiği göz önüne alındığında, standardın bu tekniği zorunlu kılması çok mantıklı olmaz . Bu nedenle, ters işlemin doğrusal karmaşıklığa sahip olmasına izin verilir. Bununla birlikte, daha önce de belirtildiği gibi, “optimizasyon” unuzu teknik olarak uygulamanıza izin verilecek şekilde t ∈ O (1) ⇒ t ∈ O ( n ) olduğunu unutmayın.

Bir Java veya benzer bir arka plandan geliyorsanız, yineleyicinin her defasında bayrağı neden kontrol etmesi gerektiğini merak edebilirsiniz. Bunun yerine, her ikisi de ortak bir taban türünden türetilen ve ayrı ayrı uygun yineleyiciye sahip olan std::list::beginve std::list::rbeginpolimorfik olarak geri dönen iki ayrı yineleyici türümüz olamaz mı? Mümkün olsa da, bu her şeyi daha da kötüleştirecektir, çünkü yineleyiciyi ilerletmek şimdi dolaylı (inline etmek zor) bir işlev çağrısı olacaktır. Java'da zaten bu fiyatı rutin olarak ödüyorsunuz, ancak daha sonra, performans kritik olduğunda birçok insanın C ++ için ulaşmasının nedenlerinden biri budur.

Tarafından işaret edildiği gibi , Benjamin Lindley beri, yorumlardaki reverseinvalidate yineleyiciler izin verilmez, sadece bir yaklaşım standardına izin verdiği çift dolaylı bellek erişimine neden Yineleyici içindeki listesine bir işaretçi geri saklamak için gibi görünüyor.

Şüphesiz, çift yönlü yineleyicileri destekleyen tüm kapsayıcılar rbegin () ve rend () kavramına sahip olduğundan, bu soru tartışmalıdır?

Yineleyicileri tersine çeviren bir proxy oluşturmak ve bu yolla kapsayıcıya erişmek çok önemlidir.

Bu işlemsizlik aslında O (1) 'dir.

gibi:

#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;
}

beklenen çıktı:

mat
the
on
sat
cat
the

Bu göz önüne alındığında, bana göre, standartlar komitesi, O'nun (1) konteynerin ters sıralamasını zorunlu kılmak için zaman almadı ve bu gerekli değildir ve standart kütüphane büyük ölçüde sadece kesinlikle gerekli olanı zorunlu kılma prensibi üzerine inşa edilmiştir. tekrardan kaçınmak.

Sadece benim 2c.

Çünkü her düğümü ( ntoplam) geçmeli ve verilerini güncellemelidir (güncelleme adımı gerçekten O(1)). Bu tüm operasyonu yapar O(n*1) = O(n).

Ayrıca her düğüm için önceki ve sonraki işaretçiyi değiştirir. Bu yüzden Lineer alır. O (1) 'de, bu LL'yi kullanan fonksiyonun LL hakkında normal veya ters erişiyormuş gibi girdi olarak alması halinde de yapılabilir.

Sadece bir algoritma açıklaması. Öğeleri içeren bir diziniz olduğunu düşünün, sonra tersine çevirmeniz gerekir. Temel fikir, ilk pozisyondaki elemanı son pozisyona, ikinci pozisyondaki elemanı sondan bir önceki pozisyona değiştiren her elemanın tekrarlanmasıdır. Dizinin ortasına geldiğinizde tüm elemanlar değişmiş olacak, böylece O (n) olarak kabul edilen (n / 2) iterasyonlarında olacaksınız.

O (n) 'dir çünkü listeyi ters sırada kopyalaması gerekir. Her bir öğe işlemi O (1) şeklindedir, ancak tüm listede n tane vardır.

Tabii ki, yeni liste için yer ayarlama ve daha sonra işaretçileri değiştirme gibi bazı sabit zamanlı işlemler vardır.