ค้นหาค่ามัธยฐานที่ใช้งานอยู่จากกระแสของจำนวนเต็ม

ซ้ำเป็นไปได้:
อัลกอริทึมค่ามัธยฐานกลิ้งใน C

ระบุว่าจำนวนเต็มอ่านจาก data stream ค้นหาค่ามัธยฐานขององค์ประกอบที่อ่านได้อย่างมีประสิทธิภาพ

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

หลังจากประมวลผลองค์ประกอบที่เข้ามาจำนวนขององค์ประกอบในกองแตกต่างกันมากที่สุด 1 องค์ประกอบ เมื่อทั้งสองฮีปมีจำนวนองค์ประกอบเท่ากันเราจะพบว่าค่าเฉลี่ยของข้อมูลรูทของฮีปนั้นเป็นค่ามัธยฐานที่มีประสิทธิภาพ เมื่อฮีปไม่สมดุลเราจะเลือกค่ามัธยฐานที่มีประสิทธิภาพจากรูทฮีปที่มีองค์ประกอบมากกว่า

แต่เราจะสร้าง heap สูงสุดและ heap สูงสุดได้อย่างไรเราจะรู้ค่ามัธยฐานที่มีประสิทธิภาพได้อย่างไร ฉันคิดว่าเราจะแทรก 1 องค์ประกอบใน max-heap แล้วองค์ประกอบ 1 ถัดไปใน min-heap และอื่น ๆ สำหรับองค์ประกอบทั้งหมด ถูกต้องฉันถ้าฉันผิดที่นี่

มีวิธีแก้ปัญหาที่แตกต่างกันจำนวนหนึ่งสำหรับการค้นหาค่ามัธยฐานจากการสตรีมข้อมูลฉันจะพูดคุยสั้น ๆ เกี่ยวกับพวกเขาในตอนท้ายของคำตอบ

คำถามเกี่ยวกับรายละเอียดของโซลูชันเฉพาะ (สูงสุด heap / min heap solution) และวิธีการทำงานของ heap based solution อธิบายไว้ด้านล่าง:

สำหรับองค์ประกอบสองรายการแรกเพิ่มขนาดเล็กลงหนึ่งใน maxHeap ด้านซ้ายและใหญ่กว่าไปยัง minHeap ทางด้านขวา จากนั้นประมวลผลสตรีมข้อมูลทีละรายการ

Step 1: Add next item to one of the heaps

   if next item is smaller than maxHeap root add it to maxHeap,
   else add it to minHeap

Step 2: Balance the heaps (after this step heaps will be either balanced or
   one of them will contain 1 more item)

   if number of elements in one of the heaps is greater than the other by
   more than 1, remove the root element from the one containing more elements and
   add to the other one

จากนั้นในเวลาใดก็ตามคุณสามารถคำนวณค่ามัธยฐานเช่นนี้:

   If the heaps contain equal amount of elements;
     median = (root of maxHeap + root of minHeap)/2
   Else
     median = root of the heap with more elements

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

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

แต่ในขณะที่คุณเห็นตัวเลขให้ติดตามการนับจำนวนครั้งที่คุณเห็นจำนวนเต็มแต่ละค่า สมมติว่าเป็นจำนวนเต็ม 4 ไบต์นั่นคือ 2 ^ 32 ที่เก็บข้อมูลหรืออย่างน้อย 2 ^ 33 จำนวนเต็ม (คีย์และนับสำหรับแต่ละ int) ซึ่งคือ 2 ^ 35 ไบต์หรือ 32GB มันอาจจะน้อยกว่านี้มากเพราะคุณไม่จำเป็นต้องเก็บคีย์หรือนับสำหรับรายการเหล่านั้นที่เป็น 0 (เช่น. เช่น defaultdict เป็นไพ ธ อน) การดำเนินการนี้ใช้เวลาคงที่เพื่อแทรกจำนวนเต็มใหม่แต่ละค่า

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

หากความแปรปรวนของข้อมูลมีการกระจายทางสถิติ (เช่นปกติบันทึกปกติ ฯลฯ ) จากนั้นการสุ่มตัวอย่างอ่างเก็บน้ำเป็นวิธีที่เหมาะสมในการประมาณค่าเปอร์เซนต์ / ค่ามัธยฐานจากจำนวนสตรีมยาวโดยพลการ

int n = 0;  // Running count of elements observed so far  
#define SIZE 10000
int reservoir[SIZE];  

while(streamHasData())
{
  int x = readNumberFromStream();

  if (n < SIZE)
  {
       reservoir[n++] = x;
  }         
  else 
  {
      int p = random(++n); // Choose a random number 0 >= p < n
      if (p < SIZE)
      {
           reservoir[p] = x;
      }
  }
}

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

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

วิธีที่มีประสิทธิภาพที่สุดในการคำนวณเปอร์เซ็นต์ไทล์ของสตรีมที่ฉันพบคืออัลกอริธึมP²: Raj Jain, Imrich Chlamtac: อัลกอริธึมP²สำหรับการคำนวณเชิงพลวัตของ Quantiiles และฮิสโตแกรมโดยไม่ต้องทำการสังเกต commun ACM 28 (10): 1076-1085 (1985)

อัลกอริทึมนั้นตรงไปตรงมาเพื่อนำไปใช้และทำงานได้ดีมาก อย่างไรก็ตามเป็นค่าประมาณดังนั้นโปรดจำไว้ว่า จากนามธรรม:

อัลกอริทึมแบบฮิวริสติกถูกนำเสนอสำหรับการคำนวณแบบไดนามิก qf ค่ามัธยฐานและค่าอื่น ๆ การประมาณการถูกสร้างขึ้นแบบไดนามิกเมื่อมีการสังเกต ข้อสังเกตจะไม่ถูกเก็บไว้; ดังนั้นอัลกอริทึมจึงมีขนาดเล็กมากและมีข้อกำหนดด้านการจัดเก็บที่แน่นอนโดยไม่คำนึงถึงจำนวนการสังเกต สิ่งนี้ทำให้มันเหมาะสำหรับการนำไปใช้ในชิปควอไทล์ที่สามารถใช้ในตัวควบคุมอุตสาหกรรมและเครื่องบันทึก อัลกอริทึมถูกขยายเพิ่มเติมเพื่อพล็อตฮิสโตแกรม วิเคราะห์ความแม่นยำของอัลกอริทึม

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

จัดทำดัชนี skiplistสนับสนุน O (LN n) แทรกการกำจัดและการค้นหาการจัดทำดัชนีขององค์ประกอบโดยพลการในขณะที่รักษาเรียงลำดับ เมื่อเชื่อมต่อกับคิว FIFOที่ติดตามรายการเก่าที่สุดลำดับที่ n การแก้ปัญหานั้นง่าย:

class RunningMedian:
    'Fast running median with O(lg n) updates where n is the window size'

    def __init__(self, n, iterable):
        self.it = iter(iterable)
        self.queue = deque(islice(self.it, n))
        self.skiplist = IndexableSkiplist(n)
        for elem in self.queue:
            self.skiplist.insert(elem)

    def __iter__(self):
        queue = self.queue
        skiplist = self.skiplist
        midpoint = len(queue) // 2
        yield skiplist[midpoint]
        for newelem in self.it:
            oldelem = queue.popleft()
            skiplist.remove(oldelem)
            queue.append(newelem)
            skiplist.insert(newelem)
            yield skiplist[midpoint]

ต่อไปนี้คือลิงก์สำหรับรหัสการทำงานที่สมบูรณ์ (เวอร์ชันคลาสที่เข้าใจง่ายและเวอร์ชันตัวสร้างที่ปรับให้เหมาะสมพร้อมกับโค้ด skiplist แบบอินไลน์ได้):

• http://code.activestate.com/recipes/576930-efficient-running-median-using-an-indexable-skipli/

• http://code.activestate.com/recipes/577073

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

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

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

Efficient เป็นคำที่ขึ้นอยู่กับบริบท วิธีแก้ไขปัญหานี้ขึ้นอยู่กับจำนวนของแบบสอบถามที่ดำเนินการสัมพันธ์กับจำนวนของการแทรก สมมติว่าคุณกำลังใส่หมายเลข N และ K คูณท้ายคุณสนใจค่ามัธยฐาน ความซับซ้อนของอัลกอริทึมที่ใช้ฮีปคือ O (N log N + K)

พิจารณาทางเลือกต่อไปนี้ ตีตัวเลขในอาร์เรย์และสำหรับแต่ละเคียวรีให้รันอัลกอริธึมการเลือกเชิงเส้น (โดยใช้ quicksort pivot พูด) ตอนนี้คุณมีอัลกอริทึมที่ใช้เวลารัน O (KN) แล้ว

ตอนนี้ถ้า K มีขนาดเล็กเพียงพอ (แบบสอบถามที่ใช้ไม่บ่อย) อัลกอริทึมหลังจะมีประสิทธิภาพมากกว่า

คุณทำสิ่งนี้ไม่ได้ด้วยกองเดียวเหรอ? อัปเดต:ไม่ ดูความคิดเห็น

ค่าคงที่: หลังจากอ่าน2*nอินพุตแล้วค่า min-heap ก็จะมีค่าnมากที่สุด

วนซ้ำ: อ่าน 2 อินพุต เพิ่มพวกเขาทั้งสองไปที่กองและลบนาทีของกอง สิ่งนี้จะสถาปนาผู้ไม่แปรเปลี่ยน

ดังนั้นเมื่อ2nอ่านอินพุตแล้วค่า min ของฮีปจะเป็นค่า nth ที่ใหญ่ที่สุด จะต้องมีความซับซ้อนเป็นพิเศษเล็กน้อยโดยเฉลี่ยทั้งสององค์ประกอบรอบ ๆ ตำแหน่งเฉลี่ยและเพื่อจัดการคิวรีหลังจากป้อนข้อมูลเป็นจำนวนคี่