Mengapa std :: list :: reverse memiliki kompleksitas O (n)?

Mengapa fungsi terbalik untuk std::listkelas di pustaka standar C ++ memiliki runtime linier? Saya akan berpikir bahwa untuk daftar yang ditautkan dua kali lipat fungsi terbalik seharusnya O (1).

Membalik daftar yang tertaut ganda harus melibatkan penggantian kepala dan ujung ekor.

Secara hipotesis, reversebisa jadi O (1) . Di sana (lagi-lagi secara hipotetis) mungkin ada anggota daftar boolean yang menunjukkan apakah arah daftar yang ditautkan saat ini sama atau berlawanan dengan yang asli tempat daftar itu dibuat.

Sayangnya, itu pada dasarnya akan mengurangi kinerja operasi lainnya (walaupun tanpa mengubah runtime asimptotik). Dalam setiap operasi, boolean perlu dikonsultasikan untuk mempertimbangkan apakah mengikuti pointer "selanjutnya" atau "sebelumnya" dari suatu tautan.

Karena ini mungkin dianggap sebagai operasi yang relatif jarang, standar (yang tidak menentukan implementasi, hanya kompleksitas), menetapkan bahwa kompleksitas dapat linier. Hal ini memungkinkan pointer "berikutnya" selalu berarti arah yang sama secara jelas, mempercepat operasi kasus biasa.

Ini bisa menjadi O (1) jika daftar akan menyimpan flag yang memungkinkan bertukar makna pointer " prev" dan " next" yang dimiliki masing-masing node. Jika membalik daftar akan menjadi operasi yang sering, penambahan semacam itu mungkin sebenarnya berguna dan saya tidak tahu alasan mengapa menerapkannya akan dilarang oleh standar saat ini. Namun, memiliki bendera seperti itu akan membuat traversal biasa dari daftar lebih mahal (jika hanya dengan faktor konstan) karena alih-alih

current = current->next;

di operator++daftar iterator, Anda akan dapatkan

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

yang bukan sesuatu yang akan Anda putuskan untuk ditambahkan dengan mudah. Mengingat bahwa daftar biasanya dilalui jauh lebih sering daripada terbalik, akan sangat tidak bijaksana jika standar mengamanatkan teknik ini. Oleh karena itu, operasi sebaliknya diizinkan untuk memiliki kompleksitas linier. Namun, perhatikan bahwa t ∈ O (1) ⇒ t ∈ O ( n ) jadi, seperti yang disebutkan sebelumnya, menerapkan "optimisasi" Anda secara teknis akan diizinkan.

Jika Anda berasal dari Jawa atau latar belakang serupa, Anda mungkin bertanya-tanya mengapa iterator harus memeriksa bendera setiap kali. Tidak bisakah sebaliknya kita memiliki dua jenis iterator yang berbeda, keduanya berasal dari tipe basis yang sama, dan memiliki std::list::begindan secara std::list::rbeginpolimorfik mengembalikan iterator yang sesuai? Meskipun mungkin, ini akan membuat semuanya menjadi lebih buruk karena memajukan iterator akan menjadi panggilan fungsi tidak langsung (sulit untuk inline) sekarang. Di Jawa, Anda membayar harga ini secara rutin, tetapi sekali lagi, ini adalah salah satu alasan banyak orang meraih C ++ ketika kinerja sangat penting.

Seperti yang ditunjukkan oleh Benjamin Lindley dalam komentar, karena reversetidak diperbolehkan untuk membatalkan iterator, satu-satunya pendekatan yang diizinkan oleh standar tampaknya menyimpan pointer kembali ke daftar di dalam iterator yang menyebabkan akses memori tidak langsung ganda.

Tentunya karena semua wadah yang mendukung iterator dua arah memiliki konsep rbegin () dan rend (), pertanyaan ini apakah bisa diperdebatkan?

Itu sepele untuk membangun proxy yang membalik iterator dan mengakses wadah melalui itu.

Non-operasi ini memang O (1).

seperti:

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

output yang diharapkan:

mat
the
on
sat
cat
the

Mengingat hal ini, bagi saya tampaknya komite standar tidak meluangkan waktu untuk mengamanatkan O (1) memesan kembali wadah karena itu tidak perlu, dan perpustakaan standar sebagian besar dibangun berdasarkan prinsip mandat hanya apa yang benar-benar diperlukan sementara menghindari duplikasi.

Hanya 2c saya.

Karena harus melintasi setiap node ( ntotal) dan memperbarui datanya (langkah pembaruan memang O(1)). Ini membuat seluruh operasi O(n*1) = O(n).

Ini juga menukar pointer sebelumnya dan berikutnya untuk setiap node. Karena itulah dibutuhkan Linear. Meskipun dapat dilakukan dalam O (1) jika fungsi menggunakan LL ini juga mengambil informasi tentang LL sebagai input seperti apakah itu mengakses secara normal atau terbalik.

Hanya penjelasan algoritma. Bayangkan Anda memiliki array dengan elemen, maka Anda perlu membalikkannya. Ide dasarnya adalah untuk beralih pada setiap elemen mengubah elemen di posisi pertama ke posisi terakhir, elemen di posisi kedua ke posisi kedua dari belakang, dan sebagainya. Ketika Anda mencapai di tengah array Anda akan memiliki semua elemen berubah, sehingga dalam (n / 2) iterasi, yang dianggap O (n).

Ini O (n) hanya karena perlu menyalin daftar dalam urutan terbalik. Setiap operasi item individu adalah O (1) tetapi ada n dari mereka di seluruh daftar.

Tentu saja ada beberapa operasi waktu konstan yang terlibat dalam mengatur ruang untuk daftar baru, dan mengubah pointer sesudahnya, dll. Notasi O tidak mempertimbangkan konstanta individual begitu Anda memasukkan faktor n orde pertama.