I>>. Полагаю, ты думаешь, что замер инициализации появился сам собой ?

>Я сам сделал его отдельно для JS — напоминаю, если у тебя снова память отказала

function Main(number) {
>>>    let watch = Date.now();
    let vals = ToArray(Select(Range(0, number), x => new TestClass()));
    let compare = (x, y) =>{
        if(x === y)
            return 0;
        if(x > y)
            return 1;
        return -1;
    };
>>>    console.warn(`Init, miliseconds: ${Date.now() - watch}`); // вот он, замер инициализации
    watch = Date.now();
    QuickSort(vals, (x,y)=>compare(x.Id, y.Id));
    console.warn(`Sort miliseconds: ${Date.now() - watch}`);
}

По твоему заявлению, JS работает у тебя намного быстрее, чем у меня (даже если взять твой любимый Хром и проигнорировать все остальные барузеры), зато C# — более чем в 2 раза медленнее. Совершенно поразительная избирательность у твоего железа.

Init, miliseconds: 4353
Total miliseconds: 1578

С# 
инициализация       1.8 секунды
сортировка          4.7 секунды

JS 
инициализация       5.5 секунды
сортировка          1.5 секунды

— на имеющемся железе(разные компы) сортировка работает в районе 1600+-200мс. А вот инициализация от 2500 до 6500мс. node 8.8.1 64

CM>То, что она сортирует — достаточно запустить и посмотреть на результат. Слишком сложно, не успеваешь за ходом мысли?

мой код от 19-го сентября, тот самый, твоя попа-боль

CM>

CM>Выделяю жирным ключевой элемент, для самых-самых сообразительных и эппло-ориентированных Вот в той строке у тебя написан бред. И мне по прежнему очень интересно, какая версия твоего кода

мой код от 19-го сентября, тот самый, твоя попа-боль

>и какой магический рантайм позволяет получить такое замечательное число на твоем тормозном железе Вопрос этот я задавал уже не один раз, и ты каждый раз уклонялся от ответа тем или иным способом

I>>Скорее всего какая нибудь лабораторная из твоих "шедевров" Ну, может и курсовая

I>Если мы про алгоритмы, то их принято доказывать, что они являются тем, что надо

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Text;

namespace QuickSort
{
    public static class SortingCheck
    {
        public static void Test()
        {
            var itemsCount = 1000_000;

            int Compare(TestClass x, TestClass y) => string.CompareOrdinal(x.Id, y.Id);

            for (var i = 0; ; i++)
            {
                var vals = Enumerable.Range(0, itemsCount).Select(x => new TestClass()).ToArray();
                QuickSort(vals, Compare);
                Check(vals, Compare);
                Console.WriteLine($"Run finished: {i}");
            }
        }

        public static void Check<T>(IList<T> vals, Func<T, T, int> compare)
        {
            for (var i = 1; i < vals.Count; i++)
            {
                if (compare(vals[i - 1], vals[i]) > 0)
                    throw new ApplicationException();
            }
        }

        public static void QuickSort<T>(T[] vals, Func<T, T, int> compare)
        {
            QuickSort(vals, compare, 0, vals.Length - 1);
        }

        public static void QuickSort<T>(T[] vals, Func<T, T, int> compare, int left, int right)
        {
            if (right <= left)
                return;

            var i = left;
            var j = right;
            var mid = (int)(((long)left + right) / 2);
            var midVal = vals[mid];

            while (i <= j)
            {
                while (compare(vals[i], midVal) < 0)
                {
                    i++;
                }

                while (compare(vals[j], midVal) > 0)
                {
                    j--;
                }

                if (i <= j)
                {
                    var tmp = vals[i];
                    vals[i] = vals[j];
                    vals[j] = tmp;

                    i++;
                    j--;
                }
            }

            QuickSort(vals, compare, left, j);
            QuickSort(vals, compare, i, right);
        }

        class TestClass
        {
            public readonly string Id;
            public readonly string Value;

            public TestClass()
            {
                Id = CreateId();
                Value = CreateId();
            }

            static readonly Random RandomGen = new Random();

            static string CreateId()
            {
                var num = (long)Math.Floor(RandomGen.NextDouble() * Math.Pow(10, 16));
                var res = num.ToString(Format, CultureInfo.InvariantCulture);
                return res;
            }

            static readonly string Format = new string('0', 8);

            public override string ToString()
            {
                return Id;
            }
        }
    }
}

CM>Хотя нет, я в магию не верю. Так что вся магия наверняка заключается в каком-то очень особом способе измерения.

— если сравнить версии нода от 6й до 9й, то внезапно окажется, что где то посередине перформанс _падает_ на сортировке, при чем значительно, около 15%.
— на имеющемся железе(разные компы) сортировка работает в районе 1600+-200мс. А вот инициализация от 2500 до 6500мс. node 8.8.1 64

Init, miliseconds: 1598
Sort miliseconds: 1573

'use strict';

const N = 1000*1000;
const re = /-/g;
const arr = Array(N);

function Main(number) {
    let watch = Date.now();
    let vals = arr; 
    
    for(let i = 0; i<arr.length; i++) {
        arr[i] = new TestClass();
    }
    
    let compare = (x, y) =>{
        if(x === y)
            return 0;
        if(x > y)
            return 1;
        return -1;
    };
    console.warn(`Init, miliseconds: ${Date.now() - watch}`);
    
    watch = Date.now();
    QuickSort(vals, (x,y)=>compare(x.Id, y.Id));
    console.warn(`Sort miliseconds: ${Date.now() - watch}`);
}

function QuickSort(vals, compare){
    QuickSortImpl(vals, compare, 0, vals.length - 1);
}

function QuickSortImpl (vals, compare, left, right) {
    if (right <= left)
        return;

    let i = left;
    let j = right;
    const mid = Math.floor((left + right) / 2);
    const midVal = vals[mid];

    while (i <= j) {
        while (compare(vals[i], midVal) > 0) {
            i++;
        }

        while (compare(vals[j], midVal) < 0) {
            j--;
        }

        if (i <= j) {
            const tmp = vals[i];
            vals[i] = vals[j];
            vals[j] = tmp;

            i++;
            j--;
        }
    }

    if(left < i - 1) {
        QuickSortImpl(vals, compare, left, i - 1);
    }

    if(right > i) {
        QuickSortImpl(vals, compare, i, right);
    }
}

class TestClass {
    constructor() {
        this.Id = CreateGuid();
        this.Value = CreateGuid();
    }

    toString() {
        return this.Id;
    }
}

function ToArray(iterator) {
    return [...iterator];
}

function* Range(start, end) {
    for(let i = start; i<end; i++) {
        yield i;
    }
}

function* Select(iterator, projector) {
    for(let x of iterator) {
        yield projector(x);
    }
}

function CreateGuid() {
    let num = 0|Math.random() * Math.pow(10, 16);

    return num.toString(16);
    //return NewGuid().toString().replace(re, "");
}

function NewGuid() {
    function s4() {
        return (((1 + Math.random()) * 0x10000) & 0xFFFF).toString(16);
    }
    return s4() + s4() + '-' + s4() + '-' + s4() + '-' +
        s4() + '-' + s4() + s4() + s4();
}

function delay(time) {
    return new Promise((resolve)=>{
        setTimeout(resolve, time);
    });
}

for(let i = 0, promise = Promise.resolve(); i<100;i++) {
    promise = promise.then(()=>Main(N)).then(()=>delay(1000));
}

Init, miliseconds: 1163
Sort miliseconds: 1654

Init, miliseconds: 1306
Sort miliseconds: 1836

I>>Если мы про алгоритмы, то их принято доказывать, что они являются тем, что надо

CM>Элементарно, если тебе яйца танцевать мешают или еще какие проблемы подобного характера.

CM>Память то у тебя какая, кстати? А то вдруг на твоем тормозожелезе стоит какой-нибудь PC4-12800

wmic MemoryChip get BankLabel, Capacity, MemoryType, TypeDetail, Speed, Tag
BankLabel  Capacity    MemoryType  Speed  Tag                TypeDetail
BANK 3     8589934592  24          1600   Physical Memory 3  128

I>>А щас выходит у тебя среднее меньше, а нижняя граница вовсе на 20% меньше моей

CM>Какая такая аномалия? Мы сравниваем твой код, только на разных компьютерах.

Аномалия в том, что: 
1 замеры в сортировке     не соответствуют разнице в мощности железа. ( НЕ СООТВЕТСТВУЮТ)
2 замеры в инициализации     соответствуют разнице в можности железе. (    СООТВЕТСТВУЮТ)

I>>GC дотнета, джавы работают похоже. Ради пару мб памяти GС и напрягаться не будет — её навалом. Кстати, в твоём коде даже GC.Collect не вызывается

CM>И такого огромного разброса, как в JS, нет. Вот ведь удивительно.

Ты наверняка сам собирал себе комп, раз "сэкономил" для такого процессора на хилой памяти. Ну может такой же "умелец" собирал конфигурацию.
Будешь смеяться, у тебя DDR3 и именно это объясняет эти полторы секунды.

I> Пропускная способность __чего__ ? Есть ответ ?

I>Кто в архиваторе занимается упаковкой, распаковкой, т.е. _вычислениями_, которые и отнимают бОльшую часть времени ? Назови этого героя И сразу станет ясно. Их целых два, кстати говоря, героя