ทำไม std :: list :: reverse มีความซับซ้อน O (n)

เหตุใดฟังก์ชันย้อนกลับสำหรับstd::listคลาสในไลบรารีมาตรฐาน C ++ จึงมี Linear runtime ฉันคิดว่าสำหรับรายการที่ลิงก์สองเท่าฟังก์ชันย้อนกลับควรเป็น O (1)

การย้อนกลับรายการที่เชื่อมโยงเป็นทวีคูณควรเกี่ยวข้องกับการสลับหัวและตัวชี้ท้าย

สมมุติฐานreverseที่จะได้รับO (1) ที่นั่น (สมมุติฐานอีกครั้ง) อาจเป็นสมาชิกรายการบูลีนที่ระบุว่าทิศทางของรายการที่เชื่อมโยงอยู่ในขณะนี้เหมือนกันหรือตรงข้ามกับต้นฉบับที่รายการถูกสร้างขึ้น

น่าเสียดายที่จะลดประสิทธิภาพของการดำเนินการอื่น ๆ เป็นหลัก (แม้ว่าจะไม่ได้เปลี่ยนรันไทม์แบบอะซิมโทติก) ในแต่ละการดำเนินการบูลีนจะต้องได้รับการพิจารณาเพื่อพิจารณาว่าจะทำตามตัวชี้ "ถัดไป" หรือ "ก่อนหน้า" ของลิงก์

ตั้งแต่นี้ถือว่าสันนิษฐานว่าเป็นการดำเนินการที่ค่อนข้างบ่อยมาตรฐาน (ซึ่งไม่ได้กำหนดใช้งานความซับซ้อนเท่านั้น) ระบุว่าความซับซ้อนอาจเป็นเชิงเส้น สิ่งนี้จะช่วยให้พอยน์เตอร์ "ถัดไป" หมายถึงทิศทางเดียวกันเสมอไปอย่างไม่น่าเชื่อทำให้การทำงานของเคสธรรมดาเป็นไปอย่างรวดเร็วขึ้น

มันอาจจะเป็นO (1) ถ้ารายการจะเก็บธงที่ช่วยให้การแลกเปลี่ยนความหมายของ“A prev” และ“ next” ชี้แต่ละโหนดมี หากการย้อนกลับรายการเป็นการดำเนินการบ่อยครั้งการเพิ่มอาจเป็นประโยชน์จริง ๆ และฉันไม่รู้ว่าทำไมการใช้งานนั้นจะถูกห้ามโดยมาตรฐานปัจจุบัน อย่างไรก็ตามการมีค่าสถานะดังกล่าวจะทำให้การสำรวจเส้นทางปกติของรายการมีราคาแพงกว่า (หากมีเพียงปัจจัยคงที่) เพราะแทนที่จะเป็น

current = current->next;

ในoperator++รายการตัววนซ้ำคุณจะได้รับ

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

ซึ่งไม่ใช่สิ่งที่คุณต้องการเพิ่มอย่างง่ายดาย ระบุว่ารายการที่มักจะมีการสำรวจมากบ่อยกว่าที่พวกเขาจะกลับก็จะไม่ฉลาดมากสำหรับมาตรฐานเพื่ออาณัติเทคนิคนี้ ดังนั้นการดำเนินการย้อนกลับได้รับอนุญาตให้มีความซับซ้อนเชิงเส้น อย่างไรก็ตามโปรดทราบว่าt permitted O (1) ⇒ t ∈ O ( n ) ดังนั้นตามที่กล่าวไว้ก่อนหน้านี้การใช้“ การเพิ่มประสิทธิภาพ” ของคุณจะได้รับอนุญาตทางเทคนิค

หากคุณมาจาก Java หรือพื้นหลังที่คล้ายกันคุณอาจสงสัยว่าทำไมตัววนซ้ำต้องตรวจสอบการตั้งค่าสถานะในแต่ละครั้ง เราไม่สามารถมีตัววนซ้ำที่แตกต่างกันสองประเภท แต่ทั้งสองมาจากประเภทพื้นฐานทั่วไปและมีstd::list::beginและstd::list::rbeginส่งคืนตัววนซ้ำที่เหมาะสมแบบ polymorphically ในขณะที่เป็นไปได้สิ่งนี้จะทำให้ทุกอย่างเลวร้ายยิ่งขึ้นเนื่องจากการเลื่อนตัววนซ้ำจะเป็นการเรียกใช้ฟังก์ชันทางอ้อม ใน Java คุณจะจ่ายราคานี้เป็นประจำอยู่แล้ว แต่อีกครั้งนี่เป็นหนึ่งในเหตุผลที่หลาย ๆ คนเข้าถึง C ++ เมื่อประสิทธิภาพมีความสำคัญ

ดังที่เบนจามินลินด์ลีย์ชี้ให้เห็นในความคิดเห็นเนื่องจากreverseไม่ได้รับอนุญาตให้ทำให้ตัววนซ้ำใช้ไม่ได้แนวทางเดียวที่ได้รับอนุญาตตามมาตรฐานดูเหมือนจะเก็บตัวชี้กลับไปยังรายการภายในตัววนซ้ำซึ่งทำให้หน่วยความจำเข้าถึง

แน่นอนเนื่องจากคอนเทนเนอร์ทั้งหมดที่สนับสนุนตัววนซ้ำแบบสองทิศทางมีแนวคิดของ rbegin () และ rend () คำถามนี้คือ moot หรือไม่?

มันไม่สำคัญเลยที่จะสร้างพร็อกซีที่ย้อนกลับตัววนซ้ำและเข้าถึงคอนเทนเนอร์ผ่านทางนั้น

การไม่ทำงานนี้เป็น O (1)

เช่น:

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

ผลลัพธ์ที่คาดหวัง:

mat
the
on
sat
cat
the

ให้ฉันดูเหมือนว่าคณะกรรมการมาตรฐานไม่ได้ใช้เวลาในการสั่ง O (1) ย้อนกลับการสั่งซื้อของภาชนะเพราะมันไม่จำเป็นและห้องสมุดมาตรฐานส่วนใหญ่สร้างขึ้นบนหลักการของการมอบสิ่งที่จำเป็นเท่านั้นในขณะที่ หลีกเลี่ยงการทำซ้ำ

แค่ 2c ของฉัน

เพราะมันต้องผ่านทุกโหนด ( nทั้งหมด) และอัปเดตข้อมูลของพวกเขา (ขั้นตอนการอัพเดทแน่นอนO(1)) O(n*1) = O(n)นี้จะทำให้การดำเนินการทั้งหมด

นอกจากนี้ยังสลับตัวชี้ก่อนหน้าและถัดไปสำหรับทุกโหนด นั่นเป็นเหตุผลว่าทำไมมันต้องใช้ Linear แม้ว่าจะสามารถทำได้ใน O (1) ถ้าฟังก์ชั่นที่ใช้ LL นี้ยังใช้ข้อมูลเกี่ยวกับ LL เป็นอินพุตเช่นไม่ว่าจะเป็นการเข้าถึงตามปกติหรือย้อนกลับ

คำอธิบายอัลกอริทึมเท่านั้น ลองนึกภาพคุณมีอาร์เรย์ที่มีองค์ประกอบจากนั้นคุณจะต้องกลับรายการ แนวคิดพื้นฐานคือการทำซ้ำในแต่ละองค์ประกอบการเปลี่ยนองค์ประกอบในตำแหน่งแรกไปยังตำแหน่งสุดท้ายองค์ประกอบในตำแหน่งที่สองไปยังตำแหน่งสุดท้ายและอื่น ๆ เมื่อคุณไปถึงจุดกึ่งกลางของอาร์เรย์คุณจะมีการเปลี่ยนแปลงองค์ประกอบทั้งหมดดังนั้นใน (n / 2) การวนซ้ำซึ่งถือว่าเป็น O (n)

เป็น O (n) เพียงเพราะต้องการคัดลอกรายการในลำดับย้อนกลับ การดำเนินการแต่ละรายการเป็น O (1) แต่มี n รายการในรายการทั้งหมด

แน่นอนว่ามีการดำเนินการเวลาคงที่ที่เกี่ยวข้องในการตั้งค่าพื้นที่สำหรับรายการใหม่และการเปลี่ยนพอยน์เตอร์ในภายหลังเป็นต้นสัญกรณ์ O จะไม่พิจารณาค่าคงที่แต่ละรายการเมื่อคุณรวมปัจจัย n ลำดับแรก