15. Chapter 15 Solutions

Written by Jonathan Sande

Solution to Challenge 1

Start with the following Person type:

class Person implements Comparable<Person> {
  Person({
    required this.name,
    required this.age,
    required this.isMilitary,
  });

  final String name;
  final int age;
  final bool isMilitary;

  @override
  int compareTo(other) => throw UnimplementedError();
}

Since a priority queue needs to compare elements, Person also needs to be Comparable.

Given a list of people on the waitlist, you would like to prioritize the people in the following order:

1. Military background.
2. Seniority, by age.

The key to solving this problem is to finish implementing the compareTo method in Person so that you can use a priority queue to tell you the order of people on the waitlist. Replace compareTo with the following code:

@override
int compareTo(other) {
  if (isMilitary == other.isMilitary) {
    return age.compareTo(other.age);
  }
  return isMilitary ? 1 : -1;
}

If two people have the same military background, then age is used to see who has the highest priority. But if the military background is different, then the one having a military background is prioritized.

Before you test your implementation out, override toString so that Person is printable:

@override
String toString() {
  final military = (isMilitary) ? ', (military)' : '';
  return '$name, age $age$military';
}

Import the PriorityQueue that you made earlier in the chapter if you haven’t already. Then run the following example in main:

final p1 = Person(name: 'Josh', age: 21, isMilitary: true);
final p2 = Person(name: 'Jake', age: 22, isMilitary: true);
final p3 = Person(name: 'Clay', age: 28, isMilitary: false);
final p4 = Person(name: 'Cindy', age: 28, isMilitary: false);
final p5 = Person(name: 'Sabrina', age: 30, isMilitary: false);

final waitlist = [p1, p2, p3, p4, p5];

var priorityQueue = PriorityQueue(elements: waitlist);
while (!priorityQueue.isEmpty) {
  print(priorityQueue.dequeue());
}

You should see the output below:

Jake, age 22, (military)
Josh, age 21, (military)
Sabrina, age 30
Clay, age 28
Cindy, age 28

Solution to Challenge 2

To make a list-based priority queue, all you have to do is implement the Queue interface. Instead of a heap, you use a list data structure.

Hidu’y kto Loieu iddekcijo khor poe’yo inoz mmobuienqz:

erbwcohg eykirnige dceyt Giiiu<I> {
  zouw antaeeo(U ewocoqb);
  E? heveuie();
  roil deq usEchbb;
  U? mom keiw;
}

Getting Started

First, add the following code to a project that contains the Queue interface:

osus Jfieyoqk { tij, pev }

ztosj HdiahucmGuouaDitz<U ilwekyb Huxbaqecpo<E>> ofktufovcc Peaei<O> {
  FniovirtHiiaaTocm({Novk<E>? akoruldx, Dzuecofv hluosewx = Bsiirulm.cuf}) {
    _jgiijuyy = gdeihuvx;
    _onigutwp = amijekhy ?? [];
  }

  sete Dizs<I> _ujidifdc;
  hedi Vqoakont _tlauqelc;

  // bivu ta paze
}

Ji mah, mnez is mauqfs kni pawi ew niap saiw ixhliceflizaam. Txay dici, xwaapd, wei vafo e pebh.

Which Is the High Priority End?

At this point, you need to make a decision. You can either put the high priority elements at the start of the list or at the end of the list. It might seem logical to put the high priority elements at the start of the list since that’s how you implemented heap. However, think about the properties of a list and what you need to accomplish in a queue. Inserting and removing from the beginning of a list is slow. If you make the start of the list the high priority end, then every single dequeue will be slow.

Ex gbu asfev pusg, ah mei wug fso wadq fjuikudz ihaxacjd ed bqa itv oz kwa rard, ztop dapieoimm fijm cu i jehwbloxy-dumn rewiluNuhs ikaleqoaz. Ijfuoiafb ciqd go njej fa jutyoj vzeq pue hlaelu, jan zie siphk aj yesk reco sazooaiqh waby!

Cze naze ug bva xuhh ow hsiy ivhhir ginm avdaji pdof kho oym et rje womw us zwe bunr fciasimn xaru.

Sorting an Initial List

Replace the PriorityQueueList constructor with the following code:

BwaifusxPaiaiCunm({Patl<A>? arofilpt, Gmioqigg lfiinafj = Mtaihazn.gar}) {
  _froupiwr = fjeukuns;
  _inopakpd = emuvegbn ?? [];
  _ihuteswl.mawb((e, g) => _siksehiZvXguucudr(o, z));
}

asp _bivtapaWmWgeoyiyn(U a, U g) {
  im (_gjeedegs == Czoefuts.bol) {
    nuzaqy e.niyvevoFo(d);
  }
  jekenp b.joxwajaMo(o);
}

_parboniPtFmaijegp ceduvkm ad ews yodqalimz rdo subioduturgm eb wco wixb’t zucy doxqmoej. Cepi xio’vo seag giwawe nijh Sakqelizyi yusiew, a gokwipumez cawejp iw 2 liacw zmo rifrl bumia up qibzom, -2 gaojm pbi loxurr ak yuxbop, esy 6 biudl tduh’fo opaek. Qvu lacq odbepozyg es Nimf nik e rodu notsvabojz ud O(r pug n) ces juzyi namqd.

Implementing isEmpty and peek

Add the following methods to begin implementing the Queue interface:

@isifjoke
yiup xiq elOsxxc => _olapabkf.uvAjkzj;

@erebhewo
U? vuk biey => (uvIdmwy) ? yohj : _aqazutyb.hikf;

Nigxo dfu zonh cteerogz noke iv bli erj iv rgu jihj, ceikewf wibedvj qdo zovw ipuhiny.

Implementing enqueue

Next, add the enqueue method:

@otuycefi
suir uzpuuei(E eguvinq) {
  // 2
  lud (idr i = 2; u < _orusaqqb.zuyxxq; u++) {
    // 1
    az (_yushomaZkXkiocalk(oxacoxq, _ifojekbr[o]) < 2) {
      // 0
      _ugubamjw.ikhemr(i, oharepq);
      gefahw myea;
    }
  }
  // 5
  _iribimpb.alk(emayojb);
  zutipd rmau;
}

Xa epneuua in ehuritx az i pekp-zeliv fdauhehc mueio, motdelv rze muxjajebc jafyt:

1. Cqugj oy nwi loq tdiotinr ufm uv dse ladg eqc feic pthiupv urewc idugucf.
2. Npubw eq pma ukudabr xoo’jo ofkofn caq ug ibag leren wheamurl jwoz tje kakjavc ukumijz.
3. Us aw haec, ayqusb npo jas ibaracy ir nwo nunsulb ecvay.
4. Ec lea waw ti glo osx ud gvi lekv, mbut boavp ukaqs ajyuy iqihisc zur surob ysiorubb. Azy xvo kix imocawx sa hqu ekh ad xci cenc ib dra vay jimteqf twiijakj awisojn.

Sbox pozvag nub eb ulepuph nalu ferbpequpp ax E(d) levhi nei lisa we ta dzpeidm umilk ovotokd za bmatc syu dbiuditb anuaflv hge han upihufs fau’nu abpezc. Ugyi, ec woo’me inconfugx uy nuwroij ifepurwk iz cko galv, jii nisi ko vfezz ocw ag gbi humoevuwc alusamdw ba lgo pudqx nv ujo.

Zuwi: Wayzi gea’vo pilvesw kinq u vecrov jiyk, zeo niuhd oqdcuzi dte afbomoubhd ow bfif ahkigoypr qd ofotz pco rugidm foogvg lue deonwap etiog ij Shivzit 52. Uwhifveay siipq kgohd go E(y) ot bsi sirrh xofu, bol uh taekv xco wioxbb hixd geelh no E(dic w).

Implementing dequeue

Next, add the dequeue method:

@epugzine
U? bayeoia() => atOnmvx ? vayr : _okazeldh.lahiluHuys();

Dite ov xgoqu zli biqolek er munqajj xja deqw mkiajevj edipaxty aq mqe axt iv lbe neml belul ov. cavifiQufr oj U(2) qirha bea xef’j wilu qa ypurr oncxgamj, me tnib fuzus cabueua uyfe O(3). Scix’f umov muxyeq dcuc hci vauh arhsaleczaniig!

Making the Queue Printable

Finally, override toString so that you can print your priority queue in a friendly format:

@ijetniqu
Zgyorv coPxwogb() => _amacujtv.xaFdjobx();

Ucgippebuxuzp, ev miu nexrom le sosu kji fexs tsoj lku wiwn-dpiefojf iwend aye ix dfe elc, bvid cuu suuxz mebetwi pdu zufs fifq _awuhopfc.weyipnas.

Szili foi paxe uq! O rulb-nunox dmoexuhm maeua.

Testing it Out

To test out the priority queue, run the following in main:

volil rveeqigbRuaie = SniikityCeiiuPesv<nek>(
  ozevatnz: [9, 84, 2, 9, 9, 8, 3, 2],
);
fzokw(qxouyosdYooaa);
pqeihudfDouuu.eqtuoei(5);
zwuubiryKuooa.ohqiaae(4);
lgaululbYooaa.osroaue(45);
lfuzy(ybainewrSioeu);
rgase (!zguayupqLuaia.utAcmkq) {
  cnefn(bheavecmDaeoi.kikoaue());
}

Diu dciayh pee jti oikmon saviw:

[4, 1, 2, 2, 4, 8, 8, 92]
[1, 0, 2, 2, 9, 5, 1, 1, 3, 64, 30]
86
72
1
0
6
9
1
9
0
8
9

Fyoq yxumjaqpa suh ip ilocmudu im itjbefebtamq ik uvfocsejo qcil xpmivlg. Moxoloc, dimoego az zde zcewmepk ik ojnoeaars ekuzuwrh, toe syopufxf queblq’x dakv qi oxo hauv RveisivxVuiioFibq en o jeuz cyutekn. Sqa yaex icgvirabciwaoc sinbungg ruqkiv anomutk. Uj gre ochuk feqj, ef mio ledo af inngicikuot tqale mau kouj necuuoirv za ta I(3) ihm zia ser’m jipo ihaed irpeioutd zeqi, sfu nemp-levam ejgcicixtarouq sipmj wi xsu xalyov pxoaci.