def sort(a, lo=None, hi=None):
if lo is None:
lo = 0
if hi is None:
hi = len(a) - 1
if lo >= hi:
return
if hi - lo + 1 < ThreeWayQuickSort.CUTOFF:
InsertionSort.sort(a, lo, hi)
return
i = lo
lt = lo
gt = hi
while i <= gt:
if util.less(a[i], a[lo]):
util.exchange(a, i, lt)
i += 1
lt += 1
elif util.less(a[lo], a[i]):
util.exchange(a, i, gt)
gt -= 1
else:
i += 1
ThreeWayQuickSort.sort(a, lo, lt - 1)
ThreeWayQuickSort.sort(a, gt + 1, hi)
def sink(tmp, k, n):
while k * 2 <= n:
child = k * 2
if child < n and less(tmp[child + 1], tmp[child]):
child = child + 1
if less(tmp[child], tmp[k]):
exchange(tmp, child, k)
k = child
else:
break
def sink(self, k):
while 2 * k <= self.N:
child = 2 * k
if child < self.N and less(self.keys[self.pq[child]], self.keys[self.pq[child+1]]):
child = child+1
if less(self.keys[self.pq[child]], self.keys[self.pq[k]]):
exchange(self.pq, k, child)
self.qp[self.pq[k]] = k
self.qp[self.pq[child]] = child
k = child
else:
break
def sort(a):
N = len(a)
for i in range(N):
k = i
for j in range(i + 1, N):
if util.less(a[j], a[k]):
k = j
util.exchange(a, i, k)
def swim(self, k):
while k > 1:
parent = k // 2
if less(self.pq[k], self.pq[parent]):
exchange(self.pq, k, parent)
k = parent
else:
break
def index_of(a, x, lo=None, hi=None):
if not is_sorted(a):
raise ValueError('array must be sorted before running selection')
if lo is None:
lo = 0
if hi is None:
hi = len(a) - 1
while lo <= hi:
mid = lo + (hi - lo) // 2
if less(x, a[mid]):
hi = mid - 1
elif less(a[mid], x):
lo = mid + 1
else:
return mid
return -1
def swim(self, k):
while k > 1:
parent = k // 2
if less(self.keys[self.pq[k]], self.keys[self.pq[parent]]):
exchange(self.pq, k, parent)
self.qp[self.pq[k]] = k
self.qp[self.pq[parent]] = parent
k = parent
else:
break
def visit(self, G, v):
self.marked[v] = True
for e in G.adj(v):
w = e.other(v)
if not self.marked[w]:
if self.pq.contains_index(w):
old_e = self.pq.get(w)
if less(e, old_e):
self.pq.decrease_key(w, e)
else:
self.pq.insert(w, e)
def sort(a, lo=None, hi=None):
if lo is None:
lo = 0
if hi is None:
hi = len(a) - 1
for i in range(lo, hi + 1):
for j in reversed(range(1, i + 1)):
if util.less(a[j], a[j - 1]):
util.exchange(a, j, j - 1)
else:
break
def sort(a):
N = len(a)
H = 0
while H < N // 3:
H = 3 * H + 1
for h in reversed(range(1, H)):
for i in range(h, N):
for j in range(i, h - 1, -h):
if util.less(a[j], a[j - h]):
util.exchange(a, j, j - h)
else:
break
def partition(a, lo, hi):
i = lo
j = hi
while True:
while not util.less(a[lo], a[i]):
i += 1
if i >= hi:
break
while util.less(a[lo], a[j]):
j -= 1
if j <= lo:
break
if i >= j:
break
util.exchange(a, i, j)
util.exchange(a, lo, j)
return j
def _merge(a, aux, lo, mid, hi):
i = lo
j = mid + 1
for k in range(lo, hi + 1):
aux[k] = a[k]
for k in range(lo, hi + 1):
if i > mid:
a[k] = aux[j]
j += 1
elif j > hi:
a[k] = aux[i]
i += 1
elif util.less(aux[i], aux[j]):
a[k] = aux[i]
i += 1
else:
a[k] = aux[j]
j += 1
def __lt__(self, other):
return util.less(self.weight, other.weight)
def test_less(self):
self.assertTrue(less(4, 5))
self.assertFalse(less(4, 4))
