How to visually show the speed difference between BubbleSort and HeapSort?

I used the BlinkyTape and implemented it in Processing (aka Java) with the help from BlinkyTape library.
The 60 LEDs where stored in an ArrayList of the class, which contains the position on the tape and the color value for the LED. The array of LEDs were initialized with a color wheel. After that the array is randomized.

First BubbleSort is executed and displayed with the same delay, the HeapSort will use in its run. Between the runs an animated color wheel cycle is displayed and prior to the next sort a new randomization takes place.

import processing.serial.*;

float numberOfLEDs = 60.0;
ArrayList<LED> leds = new ArrayList<LED>();
BlinkyTape bt = null;
int seed = 0;
int delayTime = 1000;
int delayShort = 5;
int heapSize;
int left;
int right;
int largest;
float wheelPos = 0.0;

/* ---------------------------------------------- */
class LED {
  public int positionOnTape;
  public color colorOfLED;
  
  public LED(int p, color c)
  {
    this.positionOnTape = p;
    this.colorOfLED = c;
  }  
}

/* ---------------------------------------------- */
float getWheelColor( int wcolor, float position, float min, float max)
{
    float currentPosition;
    float range;
    
    currentPosition = wheelPos + position;
    currentPosition = (currentPosition < min) ? max + currentPosition : currentPosition;
    currentPosition = (currentPosition > max) ? currentPosition - max : currentPosition;
    
    range = max - min;
    if ( 0 == wcolor )
    // RED
    {
      if ( currentPosition <= (range/3.0) ) {
        return currentPosition*3.0;
      } else if ( currentPosition <= ( range / 1.5 ) ) {
        currentPosition -= (range/3.0);
        return max - currentPosition * 3.0;
      } else
      {
        currentPosition -= (range/1.5);
        return min;
      }
    } else if ( 1 == wcolor )
    // GREEN
    {
      if ( currentPosition <= (range/3.0) ) {
        return max - currentPosition * 3.0;
      } else if ( currentPosition <= ( range / 1.5 ) ) {
        currentPosition -= (range/3.0);
        return min;
      } else
      {
        currentPosition -= (range/1.5);
        return currentPosition * 3.0;
      }
    } else
    // BLUE
    {
      if ( currentPosition <= (range/3.0) ) {
        return min;
      } else if ( currentPosition <= ( range / 1.5 ) ) {
        currentPosition -= (range/3.0);
        return currentPosition * 3.0;
      } else
      {
        currentPosition -= (range/1.5);
        return max - currentPosition * 3.0;
      }
   }
}

/* ---------------------------------------------- */
void swap(int i, int j)
{
  int tmpPos = leds.get(i).positionOnTape;
  int tmpColor = leds.get(i).colorOfLED;
  leds.get(i).positionOnTape = leds.get(j).positionOnTape;
  leds.get(i).colorOfLED = leds.get(j).colorOfLED;
  leds.get(j).positionOnTape = tmpPos;
  leds.get(j).colorOfLED = tmpColor;
  for (int k = 0; k < numberOfLEDs; k++) bt.pushPixel(leds.get(k).colorOfLED);
  bt.update();
  delay(delayShort);
}

/* ---------------------------------------------- */
void randomizeLEDs()
{
  int rnd;
  randomSeed(seed++);  
  for (int i=0; i< numberOfLEDs; i++)
  {
    rnd = (int)random(i,numberOfLEDs);
    swap(rnd,i);
  }  
}

/* ---------------------------------------------- */
void bubbleSort()
{
  int n = (int)numberOfLEDs;
  int newn = 0;
  while ( n != 0 )
  {
    newn = 0;
    for (int i = 1; i < n; i++)
    {
      if (leds.get(i-1).positionOnTape > leds.get(i).positionOnTape)
      {
        swap(i-1,i);
        newn = i;
      }
    }
    n = newn;
  }
}

/* ---------------------------------------------- */
void heapSort()
{
  buildHeap();
  for (int i=heapSize; i>0; i--)
  {
    swap(0,i);
    heapSize--;
    maxheap(0);
  }
}

void buildHeap()
{
  heapSize = (int)numberOfLEDs - 1;
  for( int i = heapSize/2; i>=0; i--)
  {
    maxheap(i);
  }
}

void maxheap(int i)
{
  left = 2 * i;
  right = 2 * i + 1;
 
  largest =
    (left <= heapSize && leds.get(left).positionOnTape > leds.get(i).positionOnTape )
    ? left
    : i;
 
  if ( right <= heapSize && leds.get(right).positionOnTape > leds.get(largest).positionOnTape )
    largest = right;
    
  if ( largest != i )
  {
    swap(i,largest);
    maxheap(largest);
  }
}

/* ---------------------------------------------- */
void rotateWheel(int howOften)
{
  int l = howOften;
  while ( l-- != 0 )
  {
    for (int j=0; j<numberOfLEDs; j++)
    {
      for (int k=0; k<numberOfLEDs; k++)
      {
        wheelPos = j;
        color c = color(
           getWheelColor( 0, k, 0.0, numberOfLEDs),
           getWheelColor( 1, k, 0.0, numberOfLEDs),
           getWheelColor( 2, k, 0.0, numberOfLEDs)
        );
        leds.get(k).colorOfLED = c;
      }
      for (int i = 0; i < numberOfLEDs; i++) bt.pushPixel(leds.get(i).colorOfLED);
      bt.update();
      delay(delayShort);
    }
  }
}

/* ---------------------------------------------- */
void setup()
{
  
  randomSeed(seed);
  
  //
  for (int i=0; i<numberOfLEDs; i++)
  {
    color c = color(
       getWheelColor( 0, i, 0.0, numberOfLEDs),
       getWheelColor( 1, i, 0.0, numberOfLEDs),
       getWheelColor( 2, i, 0.0, numberOfLEDs)
    );
    //int a = i*(128/(int)numberOfLEDs);
    //c = color(a,a,a);
    leds.add( new LED(i,c) );
  }
    
  // connect to one blinkyboard at COM9 - change to fit your setup
  for (String p : Serial.list())
  {
    if (p.startsWith("COM9") || p.startsWith("/dev/tty.usbmodem") )
    {
      bt = new BlinkyTape(this, p, 60);
    }
  }  
}

/* ---------------------------------------------- */
void draw()
{
  if (bt != null)
  {    
    randomizeLEDs();  
    
    for (int i = 0; i < numberOfLEDs; i++) bt.pushPixel(leds.get(i).colorOfLED);
    bt.update();
    delay(delayTime);

    bubbleSort(); 
    rotateWheel(5); 
    
    for (int i = 0; i < numberOfLEDs; i++) bt.pushPixel(leds.get(i).colorOfLED);
    bt.update();
    //delay(delayTime);
  
    randomizeLEDs();  
    
    for (int i = 0; i < numberOfLEDs; i++) bt.pushPixel(leds.get(i).colorOfLED);
    bt.update();
    delay(delayTime);

    heapSort();  
    rotateWheel(5); 
    
    for (int i = 0; i < numberOfLEDs; i++) bt.pushPixel(leds.get(i).colorOfLED);
    bt.update();
    //delay(delayTime);
  }

}