why this while loop performs worse than the other very similar while loop?

Question

I am trying to write a variation of insertion sort. In my algorithm, the swapping of values doesn't happen when finding the correct place for item in hand. Instead, it uses a lookup table (an array containing "links" to smaller values in the main array at corresponding positions) to find the correct position of the item. When we are done with all n elements in the main array, we haven't actually changed any of the elements in the main array itself, but an array named smaller will contain the links to immediate smaller values at positions i, i+1, ... n in correspondence to every element i, i+1, ... n in the main array. Finally, we iterate through the array smaller, starting from the index where the largest value in the main array existed, and populate another empty array in backward direction to finally get the sorted sequence.

Somewhat hacky/verbose implementation of the algorithm just described:

public static int [] sort (int[] a) {
    int length = a.length;

    int sorted [] = new int [length];
    int smaller [] = new int [length];

    //debug helpers
    long e = 0, t = 0;

    int large = 0;
    smaller[large] = -1;

    here:
    for (int i = 1; i < length; i++) {

        if (a[i] > a[large]) {
            smaller[i] = large;
            large = i;
            continue;
        }

        int prevLarge = large;
        int temp = prevLarge;

        long st = System.currentTimeMillis();
        while (prevLarge > -1 && a[prevLarge] >= a[i]) {
            e++;
            if (smaller[prevLarge] == -1) {
                smaller[i] = -1;
                smaller[prevLarge] = i;
                continue here;
            }

            temp = prevLarge;
            prevLarge = smaller[prevLarge];
        }
        long et = System.currentTimeMillis();

        t += (et - st);

        smaller[i] = prevLarge;
        smaller[temp] = i;
    }

    for (int i = length - 1; i >= 0; i--) {
        sorted[i] = a[large];
        large = smaller[large];
    }

    App.print("DevSort while loop execution: " + (e));
    App.print("DevSort while loop time: " + (t));

    return sorted;
}

The variables e and t contain the number of times the inner while loop is executed and total time taken to execute the while loop e times, respectively.

Here is a modified version of insertion sort:

public static int [] sort (int a[]) {
    int n = a.length;

    //debug helpers
    long e = 0, t = 0;

    for (int j = 1; j < n; j++) {
        int key = a[j];
        int i = j - 1;

        long st = System.currentTimeMillis();
        while ( (i > -1) && (a[i] >= key)) {
            e++;

            // simply crap
            if (1 == 1) {
                int x = 0;
                int y = 1;
                int z = 2;
            }

            a[i + 1] = a[i];
            i--;
        }
        long et = System.currentTimeMillis();

        t += (et - st);

        a[i+1] = key;
    }

    App.print("InsertSort while loop execution: " + (e));
    App.print("InsertSort while loop time: " + (t));

    return a;
}

if block inside the while loop is introduced just to match the number of statements inside the while loop of my "hacky" algorithm. Note that two variables e and t are introduced also in the modified insertion sort.

The thing that's confusing is that even though the while loop of insertion sort runs exactly equal number of times the while loop inside my "hacky" algorithm, t for insertion sort is significantly smaller than t for my algorithm.

For a particular run, if n = 10,000:

Total time taken by insertion sort's while loop: 20ms

Total time taken by my algorithm's while loop: 98ms

if n = 100,000;

Total time taken by insertion sort's while loop: 1100ms

Total time taken by my algorithm's while loop: 25251ms

In fact, because the condition 1 == 1 is always true, insertion sort's if block inside the while loop must execute more often than the one inside while loop of my algorithm. Can someone explain what's going on?

Two arrays containing same elements in the same order are being sorted using each algorithm.