@@ -1,14 +1,15 @@
 import { Animation } from "../../Animation/Animation";
 
 
+// SG 07/10/2022 22:34  https://en.wikipedia.org/wiki/Radix_sort
+
 class RadixSortLSD {
 
   getMaxValue(array) {
     let max = array[0];
     for(const num of array) {
       if(max < num) max = num;
     }
-
     return max;
   }
 
@@ -18,7 +19,10 @@ class RadixSortLSD {
     }
   }
 
-  async sort(array, exp, DOM, originalArray) {
+  async sort(array, exp, DOM, options, finalIteration) {
+    const DEAULT_COLOR = options.defaultBarColor;
+    const DELAY = options.delay;
+    const SORTED_COLOR = options.sortedBarColor;
     console.log("================================================================");
     let k = array.length;
     let sortedArray = new Array(k);
@@ -38,32 +42,36 @@ class RadixSortLSD {
       bucket[i] += bucket[i - 1];
     }
 
-    // Build the sortedArray array
+
     for (i = k - 1; i >= 0; i--) {
-      await Animation.getAnimation(4);
+      await Animation.getAnimation(DELAY);
       const oldValue = array[i]; // value being sorted to a new index
       const oldIndex = this.getIndexDOM(oldValue, DOM); // index of old value
       const sortedIndex = bucket[Math.floor(array[i] / exp) % 100] - 1;
       const valueInOldArray = array[sortedIndex];
 
-      Animation.swap(oldIndex, sortedIndex);
+      Animation.swap(oldIndex, sortedIndex); // SG 07/10/2022 22:35  swap animation 
+      if(finalIteration) {
+        DOM[oldIndex].style.backgroundColor = SORTED_COLOR;
+        DOM[sortedIndex].style.backgroundColor = SORTED_COLOR;
+      }
 
       sortedArray[sortedIndex] = oldValue;
       bucket[Math.floor(array[i] / exp) % 100]--;
     }
 
-    for (i = 0; i < k; i++) {
+    for (i = 0; i < k; i++) { // SG 07/10/2022 22:35  copying sorted values
       array[i] = sortedArray[i];
     }
   }
 
   async perform(options, array) {
     let max = this.getMaxValue(array); 
     let DOM = Array.from(document.querySelectorAll('.array-bars'));
-    let originalArray = array.slice();
 
     for(let i = 1; Math.floor(max / i) > 0; i*=100) {
-      await this.sort(array, i, DOM, originalArray);
+      // if((Math.floor(max / i*100) > 0) && i !== 1)
+      await this.sort(array, i, DOM, options, ((Math.floor(max / i*100) > 0) && i !== 1));
     }
   }
 }
Original file line number	Diff line number	Diff line change
`@@ -1,14 +1,15 @@`
`1`	`1`	`import { Animation } from "../../Animation/Animation";`
`2`	`2`
`3`	`3`
	`4`	`+// SG 07/10/2022 22:34 https://en.wikipedia.org/wiki/Radix_sort`
	`5`	`+`
`4`	`6`	`class RadixSortLSD {`
`5`	`7`
`6`	`8`	`getMaxValue(array) {`
`7`	`9`	`let max = array[0];`
`8`	`10`	`for(const num of array) {`
`9`	`11`	`if(max < num) max = num;`
`10`	`12`	`}`
`11`		`-`
`12`	`13`	`return max;`
`13`	`14`	`}`
`14`	`15`
`@@ -18,7 +19,10 @@ class RadixSortLSD {`
`18`	`19`	`}`
`19`	`20`	`}`
`20`	`21`
`21`		`- async sort(array, exp, DOM, originalArray) {`
	`22`	`+ async sort(array, exp, DOM, options, finalIteration) {`
	`23`	`+ const DEAULT_COLOR = options.defaultBarColor;`
	`24`	`+ const DELAY = options.delay;`
	`25`	`+ const SORTED_COLOR = options.sortedBarColor;`
`22`	`26`	`console.log("================================================================");`
`23`	`27`	`let k = array.length;`
`24`	`28`	`let sortedArray = new Array(k);`
`@@ -38,32 +42,36 @@ class RadixSortLSD {`
`38`	`42`	`bucket[i] += bucket[i - 1];`
`39`	`43`	`}`
`40`	`44`
`41`		`- // Build the sortedArray array`
	`45`	`+`
`42`	`46`	`for (i = k - 1; i >= 0; i--) {`
`43`		`- await Animation.getAnimation(4);`
	`47`	`+ await Animation.getAnimation(DELAY);`
`44`	`48`	`const oldValue = array[i]; // value being sorted to a new index`
`45`	`49`	`const oldIndex = this.getIndexDOM(oldValue, DOM); // index of old value`
`46`	`50`	`const sortedIndex = bucket[Math.floor(array[i] / exp) % 100] - 1;`
`47`	`51`	`const valueInOldArray = array[sortedIndex];`
`48`	`52`
`49`		`- Animation.swap(oldIndex, sortedIndex);`
	`53`	`+ Animation.swap(oldIndex, sortedIndex); // SG 07/10/2022 22:35 swap animation`
	`54`	`+ if(finalIteration) {`
	`55`	`+ DOM[oldIndex].style.backgroundColor = SORTED_COLOR;`
	`56`	`+ DOM[sortedIndex].style.backgroundColor = SORTED_COLOR;`
	`57`	`+ }`
`50`	`58`
`51`	`59`	`sortedArray[sortedIndex] = oldValue;`
`52`	`60`	`bucket[Math.floor(array[i] / exp) % 100]--;`
`53`	`61`	`}`
`54`	`62`
`55`		`- for (i = 0; i < k; i++) {`
	`63`	`+ for (i = 0; i < k; i++) { // SG 07/10/2022 22:35 copying sorted values`
`56`	`64`	`array[i] = sortedArray[i];`
`57`	`65`	`}`
`58`	`66`	`}`
`59`	`67`
`60`	`68`	`async perform(options, array) {`
`61`	`69`	`let max = this.getMaxValue(array);`
`62`	`70`	`let DOM = Array.from(document.querySelectorAll('.array-bars'));`
`63`		`- let originalArray = array.slice();`
`64`	`71`
`65`	`72`	`for(let i = 1; Math.floor(max / i) > 0; i*=100) {`
`66`		`- await this.sort(array, i, DOM, originalArray);`
	`73`	`+ // if((Math.floor(max / i*100) > 0) && i !== 1)`
	`74`	`+ await this.sort(array, i, DOM, options, ((Math.floor(max / i*100) > 0) && i !== 1));`
`67`	`75`	`}`
`68`	`76`	`}`
`69`	`77`	`}`