예제 #1
0
    def BFS(self, v):
        """ Runs breadth-first search from the source vertex v. Returns a matrix with distances from v, or None if v does not exist. """
        if v >= self.vertexCount():
            return None  # can't be run; vertex doesn't exist

        # initialize the vertex queue, the "visited" set s, and the distances from v
        q = MinHeap()
        s = set()
        distance = [float("inf")] * self.vertexCount()

        # insert the source vertex into q and set its distance as 0
        q.insert(KeyValuePair(0, v))
        s.add(v)
        distance[v] = 0

        # loop through all vertices, in order of distance from v, relaxing edges out of current vertex
        kvp = q.extractMin()
        while kvp:
            v = kvp.value
            d = kvp.key

            # relax all edges out of current vertex v
            edges = self._adj[v]
            for e in edges:
                if e.dest not in s:
                    s.add(e.dest)
                    distance[e.dest] = d + 1
                    q.insert(KeyValuePair(distance[e.dest], e.dest))

            # get next-lowest distance vertex
            kvp = q.extractMin()

        return distance
예제 #2
0
def test1():
    minhp = MinHeap()
    for idx in range(10):
        minhp.add(idx + 1)
        minhp.add(20 - idx)
    minhp.printer()

    for idx in range(20):
        print minhp.extractMin()
예제 #3
0
def test2():
    minhp = MinHeap()
    print minhp.isEmpty()
    minhp.add(1)
    minhp.add(1)
    minhp.add(1)
    minhp.printer()
    print minhp.extractMin()
    print minhp.extractMin()
예제 #4
0
def heapFullTest():
    """
    Various tests for Heap class, using both MinHeaps and MaxHeaps, including sorting and random operations.
    """
    print("Testing MinHeap: sorting")
    for i in range(1, 21):
        if heapRandomSort(250, True):
            print "Test", i, "successful"
        else:
            print "Test", i, "failed"

    print("\nTesting MaxHeap: sorting")
    for i in range(1, 21):
        if heapRandomSort(250, False):
            print "Test", i, "successful"
        else:
            print "Test", i, "failed"

    print("\nTesting MinHeap: general")
    for i in range(1, 21):
        if heapRandomTest(250, True):
            print "Test", i, "successful"
        else:
            print "Test", i, "failed"

    print("\nTesting MaxHeap: general")
    for i in range(1, 21):
        if heapRandomTest(250, False):
            print "Test", i, "successful"
        else:
            print "Test", i, "failed"

    print("\nTesting MinHeap: other operations")
    ar = [1, 4, 501, -200, 32, 7, 65, -1, 20000, -34, 17]
    min_heap = MinHeap()
    min_heap.createMinHeap(ar)

    print min_heap.extractMin()
    print min_heap.extractMin()
    print min_heap.extractMin()

    max_heap = MaxHeap()
    max_heap.createMaxHeap(ar)

    print max_heap.extractMax()
    print max_heap.extractMax()
    print max_heap.extractMax()

    print "Max: ar", max(
        ar), "min_heap", min_heap.maximum(), "max_heap", max_heap.maximum()
    print "Min: ar", min(
        ar), "min_heap", min_heap.minimum(), "max_heap", max_heap.minimum()
예제 #5
0
class Calendar(object):
    def __init__(self):
        self.events = MinHeap()
        self.mapper = {}

    def add(self, record):
        self.events.add(record.timestamp)
        if record.timestamp in self.mapper:
            self.mapper[record.timestamp].append(record)
        else:
            self.mapper[record.timestamp] = [record]

    def getlatest(self):
        rec_time = self.events.extractMin()
        rec_list = self.mapper[rec_time]
        # Logic here decides how to handle simultaneous events.
        # Current Implementation - extract departure events first
        record = None
        index = -1
        for idx in range(len(rec_list)):
            if rec_list[idx].event_type == "E":
                index = idx
                break
        if index < 0:
            record = rec_list.pop(0)
        else:
            record = rec_list.pop(index)
        if not len(rec_list):
            del self.mapper[rec_time]
        return record
예제 #6
0
    def Dijkstra(self, v):
        """ Runs Dijkstra shortest-path algorithm from source v, returning the list of distances from v, or None if any edges are negative-weight. """
        if self.hasNegativeWeight():
            return None  # Dijkstra may not run properly if any weights are negative

        # initialize the queue of vertices, the set s of "seen" or complete vertices, and the d list of current distances
        q = MinHeap()
        s = set()
        d = [float("inf")] * self.vertexCount()
        d[v] = 0

        # insert source vertex in q; could insert all if using decreaseKey, but a basic Heap implementation doesn't support that
        q.insert(KeyValuePair(d[v], v))

        # loop through each edge vertex once, in order of distance from v, relaxing all edges out of that vertex
        kvp = q.extractMin()
        while kvp:
            vert = kvp.value
            dist = kvp.key

            # only relax edges from a vertex if it has not already been visited
            if vert not in s:
                s.add(vert)
                # relax edges to vertices not already completed
                for e in self._adj[vert]:
                    if e.dest not in s:
                        if d[vert] + e.weight < d[e.dest]:
                            d[e.dest] = d[vert] + e.weight
                            q.insert(
                                KeyValuePair(d[e.dest], e.dest)
                            )  # could also decrease key, but would not work with basic Heap implementation

            # retrieve the next-lowest distance vertex
            kvp = q.extractMin()

        return d