Сортировка слиянием из 4 файлов

using System;
using System.IO;
using System.Linq;
 
static class ConsoleApp6
{
    static void Main()
    {
        // в массив запишем какие файлы считывать
        string[] nameFiles = { "Text1.txt", "Text2.txt", "Text3.txt", "Text4.txt" };
        string[] fiveArray = new string[nameFiles .Length ];
        for (int i = 0; i < nameFiles.Length; i++)
        {
            string t = File.ReadAllText(nameFiles[i]);
            int[] files = t.Split(new char[] { ',', ' ' },StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)).ToArray();
            // если не надо в консоль выводить убираем
            Console.WriteLine($"В {i+1} файле \"{nameFiles[i]}\" {string .Join (", ",files)} минимальный {files .Min()}");
            fiveArray[i] = files.Min().ToString();
        }
        File.WriteAllText("five.txt",fiveArray .Min ()); // имя файла измените
        // File.WriteAllText("five.txt", string.Join(" ", fiveArray)); // если надо все минимальные записать
        Console.ReadLine();
    }
}

using System;
using System.IO;
using System.Linq;
 
static class ConsoleApp6
{
    static void Main()
    {
        // в массив запишем какие файлы считывать
        string[] nameFiles = { "Text1.txt", "Text2.txt", "Text3.txt", "Text4.txt" };
        int [] fiveArray = new int[nameFiles .Length ];
        for (int i = 0; i < nameFiles.Length; i++)
        {
            string t = File.ReadAllText(nameFiles[i]);
            int[] files = t.Split(new char[] { ',', ' ' },StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)).ToArray();
            // если не надо в консоль выводить убираем
            Console.WriteLine($"В {i+1} файле \"{nameFiles[i]}\" {string .Join (", ",files)} минимальный {files .Min()}");
            fiveArray[i] = files[0];
        }
        File.WriteAllText("five.txt",fiveArray .Min ().ToString ()); // имя файла измените
        Console.ReadLine();
    }
}

 static void Main(string[] args)
        {
            double[] nums2 = new double [] { 2,3,17,7,8,9,1,4,6,9,2,3,1,18 };
            RecordFile(nums2); //это метод при помощи которого я вписываю изначальные числа по файлам, не обращайте внимания
 
            // в массив запишем какие файлы считывать
            string[] nameFiles = { "a.txt", "b.txt", "c.txt", "d.txt" };
            string[] fiveArray = new string[nameFiles.Length];
            int[] num = new int[4];//создаем массив с размерностью количеств наших файлов
 
            for (int i = 0; i < nameFiles.Length; i++)
            {
                string t = File.ReadAllText(nameFiles[i]);
                int[] files = t.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)).ToArray();
                //тут в каждом файле находим первые элементы всех файлов и добовляем в массив
                for (int j = 0; j < files.Length; j++)
                {
                    num[i] = files[j];
                    break;
                }
 
 
                // если не надо в консоль выводить убираем
                Console.WriteLine($"В {i + 1} файле \"{nameFiles[i]}\" {string.Join(", ", files)} минимальный {files.Min()}");
                fiveArray[i] = files.Min().ToString();
               
            }
 
            //File.WriteAllText("e.txt", fiveArray.Min()); // имя файла измените
                                                            // File.WriteAllText("five.txt", string.Join(" ", fiveArray)); // если надо все минимальные записать
            int min = num[0], minIndex = 0;
        
            for (int r = 0; r < num.Length; r++)
            {
                if (min > num[r])
                {
                    min = num[r];
                    minIndex = r;
                }
            }
            Console.Write(min + "место=" + minIndex);
 
            Console.ReadLine();
 
        }
 
    }
}

        void Test()
        {
             var file1 = new int[] { 1, 3, 5, 6 };
             var file2 = new int[] { 3, 4, 5, 7 };
             var file3 = new int[] { 1, 5, 7, 9 };
             var file4 = new int[] { 11, 12, 13, 14 };
 
             var mergedSorted = HeapMergeSort(new [] { file1, file2, file3, file4 }).ToArray();
        }
 
        private IEnumerable<T> HeapMergeSort(IEnumerable<T>[] streams)
        {
                IEnumerator<T>[] enumerators = new IEnumerator<T>[streams.Length];
                for (int i = 0; i < streams.Length; i++)
                {
                    enumerators[i] = streams[i].GetEnumerator();
                }
                
                var mergeSortMinHeap = new SortedLookup<T, int>(Comparer<T>.Default);
 
                for (int i = 0; i < enumerators.Length; ++i)
                {
                    var enumerator = enumerators[i];
                    if (enumerator.MoveNext())
                    {
                        mergeSortMinHeap.Put(enumerator.Current, i);
                    }
                }
 
                while (mergeSortMinHeap.Count != 0)
                {
                    var kvp = mergeSortMinHeap.First();
                    var value = kvp.Key;
                    var streamIndexes = kvp.Value;
 
                    mergeSortMinHeap.Remove(value);
                    foreach (var streamIndex in streamIndexes)
                    {
                        yield return value;
                    }
 
                    foreach (var streamIndex in streamIndexes)
                    {
                        var enumerator = enumerators[streamIndex];
                        if (enumerator.MoveNext())
                        {
                            mergeSortMinHeap.Put(enumerator.Current, streamIndex);
                        }
                    }
                }
            
        }
 
    public class SortedLookup<TKey, TValue>
    {
        private readonly SortedDictionary<TKey, Values<TValue>> sortedDictionary;
 
        public int Count => this.sortedDictionary.Count;
 
        public SortedLookup(IComparer<TKey> keyComparer)
        {
            this.sortedDictionary = new SortedDictionary<TKey, Values<TValue>>(keyComparer);
        }
        
        public void Put(TKey key, TValue value)
        {
            if (sortedDictionary.TryGetValue(key, out Values<TValue> valueStorage))
            {
                valueStorage.Add(value);
            }
            else
            {
                sortedDictionary.Add(key, new Values<TValue>(value));
            }
        }
 
        public void Remove(TKey key)
        {
            sortedDictionary.Remove(key);
        }
 
        public KeyValuePair<TKey, Values<TValue>> First()
        {
            return sortedDictionary.First();
        }
        
        public class Values<T> : IEnumerable<T>
        {
            private readonly T firstValue;
        
            private List<T> nextValues;
 
            public Values(T value)
            {
                this.firstValue = value;
            }
 
            public void Add(T value)
            {
                if (nextValues == null)
                {
                    nextValues = new List<T>(4);
                }
 
                nextValues.Add(value);
            }
 
            public IEnumerator<T> GetEnumerator()
            {
                yield return firstValue;
 
                if (nextValues != null)
                {
                    foreach (var value in nextValues)
                    {
                        yield return value;
                    }
                }
            }
 
            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
    }