splaytree 3.1.2 → 3.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/index.ts CHANGED
@@ -1,61 +1,62 @@
1
- import Node from './node';
2
- import { Key, Value } from './types';
3
-
4
-
5
- export type Comparator<Key> = (a:Key, b:Key) => number;
6
- export type Visitor<Key, Value> = (node:Node<Key, Value>) => void;
7
- export type NodePrinter<Key, Value> = (node:Node<Key, Value>) => string;
1
+ import Node from "./node";
2
+ import { Key, Value } from "./types";
8
3
 
4
+ export type Comparator<Key> = (a: Key, b: Key) => number;
5
+ export type Visitor<Key, Value> = (
6
+ node: Node<Key, Value>
7
+ ) => undefined | boolean | void;
8
+ export type NodePrinter<Key, Value> = (node: Node<Key, Value>) => string;
9
9
 
10
10
  /* follows "An implementation of top-down splaying"
11
11
  * by D. Sleator <sleator@cs.cmu.edu> March 1992
12
12
  */
13
13
 
14
-
15
- function DEFAULT_COMPARE (a:Key, b:Key) : number {
14
+ function DEFAULT_COMPARE(a: Key, b: Key): number {
16
15
  return a > b ? 1 : a < b ? -1 : 0;
17
16
  }
18
17
 
19
-
20
- type TreeNodeList<Key, Value> = { head:Node<Key, Value>|null };
21
-
18
+ type TreeNodeList<Key, Value> = { head: Node<Key, Value> | null };
22
19
 
23
20
  /**
24
21
  * Simple top down splay, not requiring i to be in the tree t.
25
22
  */
26
- function splay (i:Key, t:Node<Key, Value>|null, comparator:Comparator<Key>) : Node<Key, Value> {
23
+ function splay(
24
+ i: Key,
25
+ t: Node<Key, Value>,
26
+ comparator: Comparator<Key>
27
+ ): Node<Key, Value> {
27
28
  const N = new Node(null, null);
28
29
  let l = N;
29
30
  let r = N;
30
31
 
31
32
  while (true) {
32
- const cmp = comparator(i, t.key);
33
+ const cmp = comparator(i, t!.key);
33
34
  //if (i < t.key) {
34
35
  if (cmp < 0) {
35
- if (t.left === null) break;
36
+ if (t!.left === null) break;
36
37
  //if (i < t.left.key) {
37
38
  if (comparator(i, t.left.key) < 0) {
38
- const y = t.left; /* rotate right */
39
+ const y = t.left; /* rotate right */
39
40
  t.left = y.right;
40
41
  y.right = t;
41
42
  t = y;
42
43
  if (t.left === null) break;
43
44
  }
44
- r.left = t; /* link right */
45
+ r.left = t; /* link right */
45
46
  r = t;
46
47
  t = t.left;
47
- //} else if (i > t.key) {
48
+ //} else if (i > t.key) {
48
49
  } else if (cmp > 0) {
49
50
  if (t.right === null) break;
50
51
  //if (i > t.right.key) {
51
52
  if (comparator(i, t.right.key) > 0) {
52
- const y = t.right; /* rotate left */
53
+ const y = t.right; /* rotate left */
53
54
  t.right = y.left;
54
55
  y.left = t;
55
56
  t = y;
56
57
  if (t.right === null) break;
57
58
  }
58
- l.right = t; /* link left */
59
+ l.right = t; /* link left */
59
60
  l = t;
60
61
  t = t.right;
61
62
  } else break;
@@ -68,12 +69,12 @@ function splay (i:Key, t:Node<Key, Value>|null, comparator:Comparator<Key>) : No
68
69
  return t;
69
70
  }
70
71
 
71
-
72
- function insert (
73
- i:Key, data:Value,
74
- t:Node<Key, Value>,
75
- comparator:Comparator<Key>,
76
- ) : Node<Key, Value> {
72
+ function insert(
73
+ i: Key,
74
+ data: Value,
75
+ t: Node<Key, Value>,
76
+ comparator: Comparator<Key>
77
+ ): Node<Key, Value> {
77
78
  const node = new Node(i, data);
78
79
 
79
80
  if (t === null) {
@@ -95,10 +96,13 @@ function insert (
95
96
  return node;
96
97
  }
97
98
 
98
-
99
- function split (key:Key, v:Node<Key, Value>, comparator:Comparator<Key>) : {
100
- left:Node<Key, Value>|null,
101
- right:Node<Key, Value>|null,
99
+ function split(
100
+ key: Key,
101
+ v: Node<Key, Value>,
102
+ comparator: Comparator<Key>
103
+ ): {
104
+ left: Node<Key, Value> | null;
105
+ right: Node<Key, Value> | null;
102
106
  } {
103
107
  let left = null;
104
108
  let right = null;
@@ -107,82 +111,75 @@ function split (key:Key, v:Node<Key, Value>, comparator:Comparator<Key>) : {
107
111
 
108
112
  const cmp = comparator(v.key, key);
109
113
  if (cmp === 0) {
110
- left = v.left;
114
+ left = v.left;
111
115
  right = v.right;
112
116
  } else if (cmp < 0) {
113
- right = v.right;
117
+ right = v.right;
114
118
  v.right = null;
115
- left = v;
119
+ left = v;
116
120
  } else {
117
- left = v.left;
121
+ left = v.left;
118
122
  v.left = null;
119
- right = v;
123
+ right = v;
120
124
  }
121
125
  }
122
126
  return { left, right };
123
127
  }
124
128
 
125
-
126
- function merge (
127
- left:Node<Key, Value>|null,
128
- right:Node<Key, Value>|null,
129
- comparator:Comparator<Key>,
129
+ function merge(
130
+ left: Node<Key, Value> | null,
131
+ right: Node<Key, Value> | null,
132
+ comparator: Comparator<Key>
130
133
  ) {
131
134
  if (right === null) return left;
132
- if (left === null) return right;
135
+ if (left === null) return right;
133
136
 
134
137
  right = splay(left.key, right, comparator);
135
138
  right.left = left;
136
139
  return right;
137
140
  }
138
141
 
139
-
140
- type StringCollector = (s:string) => void;
141
-
142
+ type StringCollector = (s: string) => void;
142
143
 
143
144
  /**
144
145
  * Prints level of the tree
145
146
  */
146
- function printRow (
147
- root:Node<Key, Value>,
148
- prefix:string,
149
- isTail:boolean,
150
- out:StringCollector,
151
- printNode:NodePrinter<Key, Value>,
147
+ function printRow(
148
+ root: Node<Key, Value>,
149
+ prefix: string,
150
+ isTail: boolean,
151
+ out: StringCollector,
152
+ printNode: NodePrinter<Key, Value>
152
153
  ) {
153
154
  if (root) {
154
- out(`${ prefix }${ isTail ? '└── ' : '├── ' }${ printNode(root) }\n`);
155
- const indent = prefix + (isTail ? ' ' : '│ ');
156
- if (root.left) printRow(root.left, indent, false, out, printNode);
157
- if (root.right) printRow(root.right, indent, true, out, printNode);
155
+ out(`${prefix}${isTail ? "└── " : "├── "}${printNode(root)}\n`);
156
+ const indent = prefix + (isTail ? " " : "│ ");
157
+ if (root.left) printRow(root.left, indent, false, out, printNode);
158
+ if (root.right) printRow(root.right, indent, true, out, printNode);
158
159
  }
159
160
  }
160
161
 
162
+ export default class Tree<Key = number, Value = any> {
163
+ private _comparator: Comparator<Key>;
164
+ private _root: Node<Key, Value> | null = null;
165
+ private _size: number = 0;
161
166
 
162
- export default class Tree<Key=number, Value=any> {
163
-
164
- private _comparator:Comparator<Key>;
165
- private _root:Node<Key, Value>|null = null;
166
- private _size:number = 0;
167
-
168
- constructor (comparator = DEFAULT_COMPARE) {
167
+ constructor(comparator = DEFAULT_COMPARE) {
169
168
  this._comparator = comparator;
170
169
  }
171
170
 
172
-
173
171
  /**
174
172
  * Inserts a key, allows duplicates
175
173
  */
176
- public insert (key:Key, data?:Value) : Node<Key, Value> {
174
+ public insert(key: Key, data?: Value): Node<Key, Value> {
177
175
  this._size++;
178
- return this._root = insert(key, data, this._root, this._comparator);
176
+ return (this._root = insert(key, data, this._root!, this._comparator));
179
177
  }
180
178
 
181
-
182
179
  /**
183
180
  * Adds a key, if it is not present in the tree
184
181
  */
185
- public add (key:Key, data?:Value) : Node<Key, Value> {
182
+ public add(key: Key, data?: Value): Node<Key, Value> {
186
183
  const node = new Node(key, data);
187
184
 
188
185
  if (this._root === null) {
@@ -212,29 +209,26 @@ export default class Tree<Key=number, Value=any> {
212
209
  return this._root;
213
210
  }
214
211
 
215
-
216
212
  /**
217
213
  * @param {Key} key
218
214
  * @return {Node|null}
219
215
  */
220
- public remove (key:Key) : void {
221
- this._root = this._remove(key, this._root, this._comparator);
216
+ public remove(key: Key): void {
217
+ this._root = this._remove(key, this._root!, this._comparator);
222
218
  }
223
219
 
224
-
225
220
  /**
226
221
  * Deletes i from the tree if it's there
227
222
  */
228
- private _remove (
229
- i:Key, t:Node<Key, Value>,
230
- comparator:Comparator<Key>) : Node<Key, Value> {
223
+ private _remove(i: Key, t: Node<Key, Value>, comparator: Comparator<Key>) {
231
224
  let x;
232
225
  if (t === null) return null;
233
226
  t = splay(i, t, comparator);
234
227
  const cmp = comparator(i, t.key);
235
- if (cmp === 0) { /* found it */
228
+ if (cmp === 0) {
229
+ /* found it */
236
230
  if (t.left === null) {
237
- x = t.right;
231
+ x = t.right!;
238
232
  } else {
239
233
  x = splay(i, t.left, comparator);
240
234
  x.right = t.right;
@@ -242,42 +236,39 @@ export default class Tree<Key=number, Value=any> {
242
236
  this._size--;
243
237
  return x;
244
238
  }
245
- return t; /* It wasn't there */
239
+ return t; /* It wasn't there */
246
240
  }
247
241
 
248
-
249
242
  /**
250
243
  * Removes and returns the node with smallest key
251
244
  */
252
- public pop () : { key:Key, data:Value }|null {
245
+ public pop(): { key: Key; data: Value } | null {
253
246
  let node = this._root;
254
247
  if (node) {
255
248
  while (node.left) node = node.left;
256
- this._root = splay(node.key, this._root, this._comparator);
249
+ this._root = splay(node.key, this._root!, this._comparator);
257
250
  this._root = this._remove(node.key, this._root, this._comparator);
258
251
  return { key: node.key, data: node.data };
259
252
  }
260
253
  return null;
261
254
  }
262
255
 
263
-
264
256
  /**
265
257
  * Find without splaying
266
258
  */
267
- public findStatic (key:Key) : Node<Key, Value>|null {
268
- let current = this._root;
259
+ public findStatic(key: Key): Node<Key, Value> | null {
260
+ let current = this._root;
269
261
  const compare = this._comparator;
270
262
  while (current) {
271
263
  const cmp = compare(key, current.key);
272
- if (cmp === 0) return current;
264
+ if (cmp === 0) return current;
273
265
  else if (cmp < 0) current = current.left;
274
- else current = current.right;
266
+ else current = current.right;
275
267
  }
276
268
  return null;
277
269
  }
278
270
 
279
-
280
- public find (key:Key) : Node<Key, Value>|null {
271
+ public find(key: Key): Node<Key, Value> | null {
281
272
  if (this._root) {
282
273
  this._root = splay(key, this._root, this._comparator);
283
274
  if (this._comparator(key, this._root.key) !== 0) return null;
@@ -285,32 +276,30 @@ export default class Tree<Key=number, Value=any> {
285
276
  return this._root;
286
277
  }
287
278
 
288
-
289
- public contains (key:Key) : boolean {
290
- let current = this._root;
279
+ public contains(key: Key): boolean {
280
+ let current = this._root;
291
281
  const compare = this._comparator;
292
282
  while (current) {
293
283
  const cmp = compare(key, current.key);
294
- if (cmp === 0) return true;
284
+ if (cmp === 0) return true;
295
285
  else if (cmp < 0) current = current.left;
296
- else current = current.right;
286
+ else current = current.right;
297
287
  }
298
288
  return false;
299
289
  }
300
290
 
301
-
302
- public forEach (visitor:Visitor<Key, Value>, ctx?:any) : Tree<Key, Value> {
291
+ public forEach(visitor: Visitor<Key, Value>, ctx?: any): Tree<Key, Value> {
303
292
  let current = this._root;
304
- const Q = []; /* Initialize stack s */
293
+ const Q = []; /* Initialize stack s */
305
294
  let done = false;
306
295
 
307
296
  while (!done) {
308
- if (current !== null) {
297
+ if (current !== null) {
309
298
  Q.push(current);
310
299
  current = current.left;
311
300
  } else {
312
301
  if (Q.length !== 0) {
313
- current = Q.pop();
302
+ current = Q.pop()!;
314
303
  visitor.call(ctx, current);
315
304
 
316
305
  current = current.right;
@@ -320,11 +309,15 @@ export default class Tree<Key=number, Value=any> {
320
309
  return this;
321
310
  }
322
311
 
323
-
324
312
  /**
325
313
  * Walk key range from `low` to `high`. Stops if `fn` returns a value.
326
314
  */
327
- public range (low:Key, high:Key, fn:Visitor<Key, Value>, ctx?:any) : Tree<Key, Value> {
315
+ public range(
316
+ low: Key,
317
+ high: Key,
318
+ fn: Visitor<Key, Value>,
319
+ ctx?: any
320
+ ): Tree<Key, Value> {
328
321
  const Q = [];
329
322
  const compare = this._comparator;
330
323
  let node = this._root;
@@ -335,7 +328,7 @@ export default class Tree<Key=number, Value=any> {
335
328
  Q.push(node);
336
329
  node = node.left;
337
330
  } else {
338
- node = Q.pop();
331
+ node = Q.pop()!;
339
332
  cmp = compare(node.key, high);
340
333
  if (cmp > 0) {
341
334
  break;
@@ -348,55 +341,52 @@ export default class Tree<Key=number, Value=any> {
348
341
  return this;
349
342
  }
350
343
 
351
-
352
344
  /**
353
345
  * Returns array of keys
354
346
  */
355
- public keys () : Key[] {
356
- const keys:Key[] = [];
357
- this.forEach(({ key }) => keys.push(key));
347
+ public keys(): Key[] {
348
+ const keys: Key[] = [];
349
+ this.forEach(({ key }) => {
350
+ keys.push(key);
351
+ });
358
352
  return keys;
359
353
  }
360
354
 
361
-
362
355
  /**
363
356
  * Returns array of all the data in the nodes
364
357
  */
365
- public values () : Value[] {
366
- const values:Value[] = [];
367
- this.forEach(({ data }) => values.push(data));
358
+ public values(): Value[] {
359
+ const values: Value[] = [];
360
+ this.forEach(({ data }) => {
361
+ values.push(data);
362
+ });
368
363
  return values;
369
364
  }
370
365
 
371
-
372
- public min() : Key|null {
373
- if (this._root) return this.minNode(this._root).key;
366
+ public min(): Key | null {
367
+ if (this._root) return this.minNode(this._root)!.key;
374
368
  return null;
375
369
  }
376
370
 
377
-
378
- public max() : Key|null {
379
- if (this._root) return this.maxNode(this._root).key;
371
+ public max(): Key | null {
372
+ if (this._root) return this.maxNode(this._root)!.key;
380
373
  return null;
381
374
  }
382
375
 
383
-
384
- public minNode(t = this._root) : Node<Key, Value> | null {
376
+ public minNode(t = this._root): Node<Key, Value> | null {
385
377
  if (t) while (t.left) t = t.left;
386
378
  return t;
387
379
  }
388
380
 
389
-
390
- public maxNode(t = this._root) : Node<Key, Value> | null {
381
+ public maxNode(t = this._root): Node<Key, Value> | null {
391
382
  if (t) while (t.right) t = t.right;
392
383
  return t;
393
384
  }
394
385
 
395
-
396
386
  /**
397
387
  * Returns node at given index
398
388
  */
399
- public at (index:number) : Node<Key, Value>|null {
389
+ public at(index: number): Node<Key, Value> | null {
400
390
  let current = this._root;
401
391
  let done = false;
402
392
  let i = 0;
@@ -408,18 +398,17 @@ export default class Tree<Key=number, Value=any> {
408
398
  current = current.left;
409
399
  } else {
410
400
  if (Q.length > 0) {
411
- current = Q.pop();
401
+ current = Q.pop()!;
412
402
  if (i === index) return current;
413
403
  i++;
414
- current = current.right;
404
+ current = current.right!;
415
405
  } else done = true;
416
406
  }
417
407
  }
418
408
  return null;
419
409
  }
420
410
 
421
-
422
- public next (d:Node<Key, Value>) : Node<Key, Value>|null {
411
+ public next(d: Node<Key, Value>): Node<Key, Value> | null {
423
412
  let root = this._root;
424
413
  let successor = null;
425
414
 
@@ -442,8 +431,7 @@ export default class Tree<Key=number, Value=any> {
442
431
  return successor;
443
432
  }
444
433
 
445
-
446
- public prev (d:Node<Key, Value>) : Node<Key, Value>|null {
434
+ public prev(d: Node<Key, Value>): Node<Key, Value> | null {
447
435
  let root = this._root;
448
436
  let predecessor = null;
449
437
 
@@ -466,77 +454,84 @@ export default class Tree<Key=number, Value=any> {
466
454
  return predecessor;
467
455
  }
468
456
 
469
-
470
- public clear () : Tree<Key, Value> {
457
+ public clear(): Tree<Key, Value> {
471
458
  this._root = null;
472
459
  this._size = 0;
473
460
  return this;
474
461
  }
475
462
 
476
-
477
463
  public toList() {
478
- return toList(this._root);
464
+ return toList(this._root!);
479
465
  }
480
466
 
481
-
482
467
  /**
483
468
  * Bulk-load items. Both array have to be same size
484
469
  */
485
- public load (keys:Key[], values:Value[] = [], presort:boolean = false) {
470
+ public load(keys: Key[], values: Value[] = [], presort: boolean = false) {
486
471
  let size = keys.length;
487
472
  const comparator = this._comparator;
488
473
 
489
474
  // sort if needed
490
475
  if (presort) sort(keys, values, 0, size - 1, comparator);
491
476
 
492
- if (this._root === null) { // empty tree
477
+ if (this._root === null) {
478
+ // empty tree
493
479
  this._root = loadRecursive(keys, values, 0, size);
494
480
  this._size = size;
495
- } else { // that re-builds the whole tree from two in-order traversals
496
- const mergedList = mergeLists(this.toList(), createList(keys, values), comparator);
481
+ } else {
482
+ // that re-builds the whole tree from two in-order traversals
483
+ const mergedList = mergeLists(
484
+ this.toList(),
485
+ createList(keys, values),
486
+ comparator
487
+ );
497
488
  size = this._size + size;
498
489
  this._root = sortedListToBST({ head: mergedList }, 0, size);
499
490
  }
500
491
  return this;
501
492
  }
502
493
 
494
+ public isEmpty(): boolean {
495
+ return this._root === null;
496
+ }
503
497
 
504
- public isEmpty() : boolean { return this._root === null; }
505
-
506
-
507
- get size () : number { return this._size; }
508
- get root () : Node<Key, Value>|null { return this._root; }
509
-
510
- public toString (printNode:NodePrinter<Key, Value> = (n) => String(n.key)) : string {
511
- const out:string[] = [];
512
- printRow(this._root, '', true, (v) => out.push(v), printNode);
513
- return out.join('');
498
+ get size(): number {
499
+ return this._size;
500
+ }
501
+ get root(): Node<Key, Value> | null {
502
+ return this._root;
514
503
  }
515
504
 
505
+ public toString(
506
+ printNode: NodePrinter<Key, Value> = (n) => String(n.key)
507
+ ): string {
508
+ const out: string[] = [];
509
+ printRow(this._root!, "", true, (v) => out.push(v), printNode);
510
+ return out.join("");
511
+ }
516
512
 
517
- public update (key:Key, newKey:Key, newData?:Value) : void {
513
+ public update(key: Key, newKey: Key, newData?: Value): void {
518
514
  const comparator = this._comparator;
519
- let { left, right } = split(key, this._root, comparator);
515
+ let { left, right } = split(key, this._root!, comparator);
520
516
  if (comparator(key, newKey) < 0) {
521
- right = insert(newKey, newData, right, comparator);
517
+ right = insert(newKey, newData, right!, comparator);
522
518
  } else {
523
- left = insert(newKey, newData, left, comparator);
519
+ left = insert(newKey, newData, left!, comparator);
524
520
  }
525
521
  this._root = merge(left, right, comparator);
526
522
  }
527
523
 
528
-
529
- public split(key:Key) {
530
- return split(key, this._root, this._comparator);
524
+ public split(key: Key) {
525
+ return split(key, this._root!, this._comparator);
531
526
  }
532
527
 
533
528
  *[Symbol.iterator]() {
534
529
  let current = this._root;
535
- const Q: Node<Key, Value>[] = []; /* Initialize stack s */
530
+ const Q: Node<Key, Value>[] = []; /* Initialize stack s */
536
531
  let done = false;
537
532
 
538
533
  while (!done) {
539
- if (current !== null) {
534
+ if (current !== null) {
540
535
  Q.push(current);
541
536
  current = current.left;
542
537
  } else {
@@ -551,34 +546,36 @@ export default class Tree<Key=number, Value=any> {
551
546
  }
552
547
  }
553
548
 
554
-
555
- function loadRecursive (keys:Key[], values:Value[], start:number, end:number) : Node<Key, Value>|null {
549
+ function loadRecursive(
550
+ keys: Key[],
551
+ values: Value[],
552
+ start: number,
553
+ end: number
554
+ ): Node<Key, Value> | null {
556
555
  const size = end - start;
557
556
  if (size > 0) {
558
557
  const middle = start + Math.floor(size / 2);
559
- const key = keys[middle];
560
- const data = values[middle];
561
- const node = new Node(key, data);
562
- node.left = loadRecursive(keys, values, start, middle);
563
- node.right = loadRecursive(keys, values, middle + 1, end);
558
+ const key = keys[middle];
559
+ const data = values[middle];
560
+ const node = new Node(key, data);
561
+ node.left = loadRecursive(keys, values, start, middle);
562
+ node.right = loadRecursive(keys, values, middle + 1, end);
564
563
  return node;
565
564
  }
566
565
  return null;
567
566
  }
568
567
 
569
-
570
- function createList(keys:Key[], values:Value[]) : Node<Key, Value> {
568
+ function createList(keys: Key[], values: Value[]): Node<Key, Value> {
571
569
  const head = new Node<Key, Value>(null, null);
572
- let p:Node<Key, Value> = head;
570
+ let p: Node<Key, Value> = head;
573
571
  for (let i = 0; i < keys.length; i++) {
574
572
  p = p.next = new Node(keys[i], values[i]);
575
573
  }
576
574
  p.next = null;
577
- return head.next;
575
+ return head.next!;
578
576
  }
579
577
 
580
-
581
- function toList (root:Node<Key, Value>) : Node<Key, Value> {
578
+ function toList(root: Node<Key, Value>): Node<Key, Value> {
582
579
  let current = root;
583
580
  const Q = [];
584
581
  let done = false;
@@ -589,53 +586,57 @@ function toList (root:Node<Key, Value>) : Node<Key, Value> {
589
586
  while (!done) {
590
587
  if (current) {
591
588
  Q.push(current);
592
- current = current.left;
589
+ current = current.left!;
593
590
  } else {
594
591
  if (Q.length > 0) {
595
- current = p = p.next = Q.pop();
596
- current = current.right;
592
+ current = p = p.next = Q.pop()!;
593
+ current = current.right!;
597
594
  } else done = true;
598
595
  }
599
596
  }
600
597
  p.next = null; // that'll work even if the tree was empty
601
- return head.next;
598
+ return head.next!;
602
599
  }
603
600
 
604
-
605
- function sortedListToBST(list:TreeNodeList<Key, Value>, start:number, end:number) : Node<Key, Value> {
601
+ function sortedListToBST(
602
+ list: TreeNodeList<Key, Value>,
603
+ start: number,
604
+ end: number
605
+ ) {
606
606
  const size = end - start;
607
607
  if (size > 0) {
608
608
  const middle = start + Math.floor(size / 2);
609
609
  const left = sortedListToBST(list, start, middle);
610
610
 
611
611
  const root = list.head;
612
- root.left = left;
612
+ root!.left = left;
613
613
 
614
- list.head = list.head.next;
614
+ list.head = list.head!.next;
615
615
 
616
- root.right = sortedListToBST(list, middle + 1, end);
617
- return root;
616
+ root!.right = sortedListToBST(list, middle + 1, end);
617
+ return root!;
618
618
  }
619
619
  return null;
620
620
  }
621
621
 
622
-
623
- function mergeLists<Key, Value> (
624
- l1:Node<Key, Value>, l2:Node<Key, Value>,
625
- compare:Comparator<Key>) : Node<Key, Value> {
626
- const head:Node<Key, Value> = new Node<Key, Value>(null, null); // dummy
622
+ function mergeLists<Key, Value>(
623
+ l1: Node<Key, Value>,
624
+ l2: Node<Key, Value>,
625
+ compare: Comparator<Key>
626
+ ): Node<Key, Value> {
627
+ const head: Node<Key, Value> = new Node<Key, Value>(null as Key, null); // dummy
627
628
  let p = head;
628
629
 
629
- let p1:Node<Key, Value> = l1;
630
- let p2:Node<Key, Value> = l2;
630
+ let p1: Node<Key, Value> = l1;
631
+ let p2: Node<Key, Value> = l2;
631
632
 
632
633
  while (p1 !== null && p2 !== null) {
633
634
  if (compare(p1.key, p2.key) < 0) {
634
635
  p.next = p1;
635
- p1 = p1.next;
636
+ p1 = p1.next!;
636
637
  } else {
637
638
  p.next = p2;
638
- p2 = p2.next;
639
+ p2 = p2.next!;
639
640
  }
640
641
  p = p.next;
641
642
  }
@@ -646,13 +647,15 @@ function mergeLists<Key, Value> (
646
647
  p.next = p2;
647
648
  }
648
649
 
649
- return head.next;
650
+ return head.next!;
650
651
  }
651
652
 
652
-
653
653
  function sort(
654
- keys:Key[], values:Value[],
655
- left:number, right:number, compare:Comparator<Key>,
654
+ keys: Key[],
655
+ values: Value[],
656
+ left: number,
657
+ right: number,
658
+ compare: Comparator<Key>
656
659
  ) {
657
660
  if (left >= right) return;
658
661
 
@@ -661,8 +664,10 @@ function sort(
661
664
  let j = right + 1;
662
665
 
663
666
  while (true) {
664
- do i++; while (compare(keys[i], pivot) < 0);
665
- do j--; while (compare(keys[j], pivot) > 0);
667
+ do i++;
668
+ while (compare(keys[i], pivot) < 0);
669
+ do j--;
670
+ while (compare(keys[j], pivot) > 0);
666
671
  if (i >= j) break;
667
672
 
668
673
  let tmp = keys[i];
@@ -674,6 +679,6 @@ function sort(
674
679
  values[j] = tmp;
675
680
  }
676
681
 
677
- sort(keys, values, left, j, compare);
682
+ sort(keys, values, left, j, compare);
678
683
  sort(keys, values, j + 1, right, compare);
679
684
  }