Apakah python memiliki daftar yang disortir?

Maksud saya struktur dengan:

• O (log n) kompleksitas untuk x.push()operasi
• O (log n) kompleksitas untuk menemukan elemen
• O (n) kompleksitas untuk menghitung list(x)yang akan diurutkan

Saya juga punya pertanyaan terkait tentang kinerja list(...).insert(...)yang sekarang ada di sini .

Daftar Python standar tidak diurutkan dalam bentuk apa pun. Modul heapq standar dapat digunakan untuk menambahkan dalam O (log n) ke daftar yang ada dan menghapus yang terkecil di O (log n), tetapi bukan daftar yang diurutkan dalam definisi Anda.

Ada berbagai implementasi pohon seimbang untuk Python yang memenuhi persyaratan Anda, misalnya rbtree , RBTree , atau pyavl .

Apakah ada alasan khusus untuk persyaratan O besar Anda? Atau Anda hanya ingin cepat? The sortedcontainers modul murni Python dan cepat (seperti dalam implementasi cepat-sebagai-C seperti blist dan rbtree).

The perbandingan kinerja menunjukkan itu benchmark lebih cepat atau setara dengan blist ini diurutkan daftar jenis. Perhatikan juga bahwa rbtree, RBTree, dan PyAVL memberikan dict dict dan atur tipe tetapi tidak memiliki tipe daftar diurutkan.

Jika kinerja merupakan persyaratan, selalu ingat untuk melakukan tolok ukur. Modul yang mendukung klaim cepat dengan notasi Big-O harus dicurigai sampai ia juga menunjukkan perbandingan benchmark.

Penafian: Saya penulis modul Python diurutkan kontainer.

Instalasi:

pip install sortedcontainers

Pemakaian:

>>> from sortedcontainers import SortedList
>>> l = SortedList()
>>> l.update([0, 4, 1, 3, 2])
>>> l.index(3)
3
>>> l.add(5)
>>> l[-1]
5

Meskipun saya masih belum pernah memeriksa kecepatan "O besar" dari operasi daftar Python dasar, bisectmodul standar mungkin juga layak disebutkan dalam konteks ini:

import bisect
L = [0, 100]

bisect.insort(L, 50)
bisect.insort(L, 20)
bisect.insort(L, 21)

print L
## [0, 20, 21, 50, 100]

i = bisect.bisect(L, 20)
print L[i-1], L[i]
## 20, 21

PS. Ah, maaf, bisectdisebutkan dalam pertanyaan yang dirujuk. Tetap saja, saya pikir tidak akan banyak bahaya jika informasi ini ada di sini)

PPS. Dan daftar CPython sebenarnya adalah array (bukan, katakanlah, daftar hitam atau lain-lain). Yah, saya kira mereka harus sesuatu yang sederhana, tetapi bagi saya, namanya agak menyesatkan.

Jadi, jika saya tidak salah, kecepatan dua bagian / daftar mungkin akan:

• untuk dorongan (): O (n) untuk kasus terburuk;
• untuk pencarian: jika kami menganggap kecepatan pengindeksan array menjadi O (1), pencarian harus menjadi operasi O (log (n));
• untuk pembuatan daftar: O (n) harus menjadi kecepatan penyalinan daftar, jika tidak maka O (1) untuk daftar yang sama)

Pembaruan. Setelah diskusi dalam komentar, izinkan saya menautkan di sini pertanyaan SO ini: Bagaimana Daftar Python Diimplementasikan dan Apa kompleksitas runtime dari fungsi daftar python

import bisect

class sortedlist(list):
    '''just a list but with an insort (insert into sorted position)'''
    def insort(self, x):
        bisect.insort(self, x)

Meskipun tidak (belum) menyediakan fungsi pencarian khusus, heapqmodul mungkin sesuai dengan kebutuhan Anda. Ini mengimplementasikan antrian tumpukan menggunakan daftar biasa. Anda harus menulis tes keanggotaan efisien Anda sendiri yang menggunakan struktur internal antrian (yang dapat dilakukan di O (log n) , menurut saya ...). Ada satu kelemahan: mengekstraksi daftar yang diurutkan memiliki kompleksitas O (n log n) .

Saya akan menggunakan modul biscectatau sortedcontainers. Saya tidak benar-benar berpengalaman, tapi saya pikir heapqmodul ini berfungsi. Berisi aHeap Queue

Mungkin tidak sulit untuk mengimplementasikan daftar sortir Anda sendiri di Python. Di bawah ini adalah bukti konsep:

import bisect

class sortlist:
    def __init__(self, list):
        self.list = list
        self.sort()
    def sort(self):
        l = []
        for i in range(len(self.list)):
            bisect.insort(l, self.list[i])
        self.list = l
        self.len = i
    def insert(self, value):
        bisect.insort(self.list, value)
        self.len += 1
    def show(self):
        print self.list
    def search(self,value):
        left = bisect.bisect_left(self.list, value)
        if abs(self.list[min([left,self.len-1])] - value) >= abs(self.list[left-1] - value):
            return self.list[left-1]
        else:
            return self.list[left]

list = [101, 3, 10, 14, 23, 86, 44, 45, 45, 50, 66, 95, 17, 77, 79, 84, 85, 91, 73]
slist = sortlist(list)
slist.show()
slist.insert(99)
slist.show()
print slist.search(100000000)
print slist.search(0)
print slist.search(56.7)

========= Hasil ============

[3, 10, 14, 17, 23, 44, 45, 45, 50, 66, 73, 77, 79, 84, 85, 86, 91, 95, 101]

[3, 10, 14, 17, 23, 44, 45, 45, 50, 66, 73, 77, 79, 84, 85, 86, 91, 95, 99, 101]

101

3

50