C# LinkedList.OrderBy方法代码示例

        private void Sjfnp()
        {
            SortedProcesses = new LinkedList<Process>();
            var orderedEnumerable = Processes.OrderBy(x => x.ArrivalTime).ThenBy(x => x.BurstTime).ThenBy(x => x.Name);
            var tmpProcesses = new LinkedList<Process>(orderedEnumerable);
            var intrProcesses = new LinkedList<Process>();
            var currentTime = tmpProcesses.First.Value.ArrivalTime;
            while (tmpProcesses.First != null)
            {
                if (Math.Abs(currentTime - tmpProcesses.First.Value.ArrivalTime) < 0.0001)
                {
                    var tmp = tmpProcesses.First.Value;
                    tmpProcesses.Remove(tmp);
                    SortedProcesses.AddLast(tmp);
                    currentTime += tmp.BurstTime;
                }
                else if (currentTime > tmpProcesses.First.Value.ArrivalTime)
                {
                    var itr = tmpProcesses.First;
                    while (itr != null && currentTime > itr.Value.ArrivalTime)
                    {
                        var tmp = itr.Value;
                        tmpProcesses.Remove(tmp);
                        intrProcesses.AddLast(tmp);
                        itr = tmpProcesses.First;
                    }
                    var orderedEnumerable2 = intrProcesses.OrderBy(x => x.BurstTime).ThenBy(x => x.ArrivalTime).ThenBy(x => x.Name);
                    intrProcesses = new LinkedList<Process>(orderedEnumerable2);
                    while (intrProcesses.First != null)
                    {
                        var tmp = intrProcesses.First.Value;
                        intrProcesses.Remove(tmp);
                        SortedProcesses.AddLast(tmp);
                        currentTime += tmp.BurstTime;
                    }

                }
                else if (currentTime < tmpProcesses.First.Value.ArrivalTime)
                {
                    currentTime = tmpProcesses.First.Value.ArrivalTime;
                }
            }
        }

        public void SelectATK(BattlePhase _battlephase,Player _player, Computer _computer)
        {
            Card monsterbeATK;
            int minBattlePoint;
            Card monsteratk;
            if (_player.MonsterField.ListCard.Any())
            {
                // chọn trước lá bị tấn công
                minBattlePoint = _player.MonsterField.ListCard.Min(card => (card as Monster).BattlePoint);
                monsterbeATK = _player.MonsterField.ListCard.Where(card => (card as Monster).BattlePoint == minBattlePoint).First();
            }
            else
            {
                minBattlePoint = 0;
                monsterbeATK = null;
            }
            if (_battlephase.List_monsterATK.Any())
            {
                LinkedList<Card> list = new LinkedList<Card>(
                    _battlephase.List_monsterATK
                    .Where(card =>  (card as Monster).Atk > minBattlePoint));

                if (list.Any())
                {
                    monsteratk = list
                        .OrderBy(card => (card as Monster).Atk)
                        .First();
                }
                else
                    monsteratk = null;
            }
            else
            {
                monsteratk = null;
            }
            _battlephase.MonsterATK = monsteratk as Monster;
            if (_battlephase.MonsterATK != null)
                _battlephase.MonsterBeATK = monsterbeATK as Monster;
            else
                _battlephase.MonsterBeATK = null;
        }

 static void Añadir(LinkedList<Nodo> C, Nodo Y) {
     LinkedList<Nodo> aux = new LinkedList<Nodo>(C);
     aux.AddLast(Y);
     C.Clear();
     foreach(Nodo X in aux.OrderBy(x => x.Cestimado)) {
         C.AddLast(X);
     }
     //************************************************************
     Console.WriteLine("(+) Se añade " + (char)(A + Y.lugar));
     Mostrar(C);
     //************************************************************
 }

        private static void SetFinalLength(DefinitionBase[] definitions, double gridFinalLength)
        {
            double occupiedLength = 0d;

            var stars = new LinkedList<DefinitionBase>();
            var nonStarDefinitions = new LinkedList<DefinitionBase>();

            foreach (DefinitionBase definition in definitions)
            {
                double minLength;

                switch (definition.UserLength.GridUnitType)
                {
                    case GridUnitType.Auto:
                        minLength = definition.MinLength;

                        definition.FinalLength = minLength.Coerce(definition.MinLength, definition.UserMaxLength);

                        occupiedLength += definition.FinalLength;
                        nonStarDefinitions.AddFirst(definition);
                        break;
                    case GridUnitType.Pixel:
                        minLength = definition.UserLength.Value;

                        definition.FinalLength = minLength.Coerce(definition.MinLength, definition.UserMaxLength);

                        occupiedLength += definition.FinalLength;
                        nonStarDefinitions.AddFirst(definition);
                        break;
                    case GridUnitType.Star:
                        double numerator = definition.UserLength.Value;
                        if (numerator.IsCloseTo(0d))
                        {
                            definition.Numerator = 0d;
                            definition.StarAllocationOrder = 0d;
                        }
                        else
                        {
                            definition.Numerator = numerator;
                            definition.StarAllocationOrder = Math.Max(definition.MinLength, definition.UserMaxLength) /
                                                             numerator;
                        }

                        stars.AddLast(definition);
                        break;
                }
            }

            if (stars.Count > 0)
            {
                DefinitionBase[] sortedStars = stars.OrderBy(o => o.StarAllocationOrder).ToArray();

                double denominator = 0d;
                foreach (DefinitionBase definitionBase in sortedStars.Reverse())
                {
                    denominator += definitionBase.Numerator;
                    definitionBase.Denominator = denominator;
                }

                foreach (DefinitionBase definition in sortedStars)
                {
                    double length;
                    if (definition.Numerator.IsCloseTo(0d))
                    {
                        length = definition.MinLength;
                    }
                    else
                    {
                        double remainingLength = (gridFinalLength - occupiedLength).EnsurePositive();
                        length = remainingLength * (definition.Numerator / definition.Denominator);
                        length = length.Coerce(definition.MinLength, definition.UserMaxLength);
                    }

                    occupiedLength += length;
                    definition.FinalLength = length;
                }
            }

            if (occupiedLength.IsGreaterThan(gridFinalLength))
            {
                IOrderedEnumerable<DefinitionBase> sortedDefinitions =
                    stars.Concat(nonStarDefinitions).OrderBy(o => o.FinalLength - o.MinLength);

                double excessLength = occupiedLength - gridFinalLength;
                int i = 0;
                foreach (DefinitionBase definitionBase in sortedDefinitions)
                {
                    double finalLength = definitionBase.FinalLength - (excessLength / (definitions.Length - i));
                    finalLength = finalLength.Coerce(definitionBase.MinLength, definitionBase.FinalLength);
                    excessLength -= definitionBase.FinalLength - finalLength;

                    definitionBase.FinalLength = finalLength;
                    i++;
                }
            }

            definitions[0].FinalOffset = 0d;
            for (int i = 1; i < definitions.Length; i++)
            {
                DefinitionBase previousDefinition = definitions[i - 1];
//.........这里部分代码省略.........

        private static void AllocateProportionalSpace(IEnumerable<DefinitionBase> definitions, double availableLength)
        {
            double occupiedLength = 0d;

            var stars = new LinkedList<DefinitionBase>();

            foreach (DefinitionBase definition in definitions)
            {
                switch (definition.LengthType)
                {
                    case GridUnitType.Auto:
                        occupiedLength += definition.MinLength;
                        break;
                    case GridUnitType.Pixel:
                        occupiedLength += definition.AvailableLength;
                        break;
                    case GridUnitType.Star:
                        double numerator = definition.UserLength.Value;
                        if (numerator.IsCloseTo(0d))
                        {
                            definition.Numerator = 0d;
                            definition.StarAllocationOrder = 0d;
                        }
                        else
                        {
                            definition.Numerator = numerator;
                            definition.StarAllocationOrder = Math.Max(definition.MinLength, definition.UserMaxLength) /
                                                             numerator;
                        }

                        stars.AddLast(definition);
                        break;
                }
            }

            if (stars.Count > 0)
            {
                DefinitionBase[] sortedStars = stars.OrderBy(o => o.StarAllocationOrder).ToArray();

                double denominator = 0d;
                foreach (DefinitionBase definition in sortedStars.Reverse())
                {
                    denominator += definition.Numerator;
                    definition.Denominator = denominator;
                }

                foreach (DefinitionBase definition in sortedStars)
                {
                    double length;
                    if (definition.Numerator.IsCloseTo(0d))
                    {
                        length = definition.MinLength;
                    }
                    else
                    {
                        double remainingLength = (availableLength - occupiedLength).EnsurePositive();
                        length = remainingLength * (definition.Numerator / definition.Denominator);
                        length = length.Coerce(definition.MinLength, definition.UserMaxLength);
                    }

                    occupiedLength += length;
                    definition.AvailableLength = length;
                }
            }
        }

        static void Main(string[] args)
        {
            // ------ TASK 1 --------
            var collection1 = new CollectionType<string>();
            collection1.Insert("first element");
            collection1.Insert("second element");
            Console.Write("Collection: ");
            collection1.Print();
            Console.WriteLine("Access by index: {0}", collection1[1]);

            // --------- TASK 2 --------
            var collection2 = new CollectionType<Figure>();
            var fig1 = new Figure(1, 1, "A");
            var fig2 = new Figure(2, 2, "B");
            var fig3 = new Figure(3, 3, "C");
            var fig4 = new Figure(4, 4, "D");
            collection2.Insert(fig1);
            collection2.Insert(fig4);
            collection2.Insert(fig3);
            collection2.Insert(fig2);
            collection2.Print();
            collection2.WriteToFile("collection.txt");
            Console.Write("Minimum: {0}", collection2.GetMin());
            Console.Write("Maximum: {0}", collection2.GetMax());
            Console.Write("Of size 2: {0}", collection2.GetCollectionOfSize(2));

            // --------- TASK 3 --------
            Console.WriteLine("***********");
            var linkedLst = new LinkedList<string>();
            linkedLst.AddLast("123");
            linkedLst.AddLast("456");
            linkedLst.AddLast("1");
            linkedLst.AddLast("12345");
            linkedLst.AddLast("oppasadjn");
            linkedLst.AddLast("4815162342");
            var stream = new StreamWriter("linkedList.txt");
            foreach (var vr in linkedLst)
            {
                Console.WriteLine(vr);
                stream.WriteLine(vr);
            }
            stream.Close();
            Console.WriteLine("Find 123: {0}", linkedLst.Contains("123"));
            Console.WriteLine("Sorted linked list:");
            foreach (var vr in linkedLst.OrderBy(i => i))
            {
                Console.WriteLine(vr);
            }
            Console.WriteLine("Sorted linked list in back order:");
            foreach (var vr in linkedLst.OrderByDescending(i => i))
            {
                Console.WriteLine(vr);
            }
            Console.WriteLine("Number of strings with length of 3: {0}", GetCountByLength(linkedLst, 3));

            Console.WriteLine("Min element: {0}", linkedLst.Select(i => i).Min());
            Console.WriteLine("Max element: {0}", linkedLst.Select(i => i).Max());
            Console.WriteLine("Number of strings with length LINQ: {0}", linkedLst.Count(i => i.Length == 3));

            Console.ReadKey();
        }

        public static IEnumerable<EmployeeCountByIntervalLine> GetEmployeeCountByInterval(DateTime initialDate, DateTime finalDate, TimeIntervalType timeInterval)
        {
            EmployeeCache.UpdateData(initialDate, finalDate);
            var employees = EmployeeCache.CachedData;

            // Query:
            var employeesQuery = from employee in employees
                                 where employee.HiredOn <= finalDate &&
                                       (employee.FiredOn >= initialDate || employee.FiredOn == DateTime.MinValue)
                                 select employee;

            var dateTimes = new List<DateTime>();
            if (timeInterval == TimeIntervalType.Year)
            {
                var temp = new DateTime(initialDate.Year, 1, 1);
                for (int i = 0; i < finalDate.Year - initialDate.Year + 1; i++)
                    dateTimes.Add(temp.AddYears(i));
            }
            else
            {
                var temp = new DateTime(initialDate.Year, initialDate.Month, 1);
                int months = ((finalDate.Year - initialDate.Year) * 12) + finalDate.Month - initialDate.Month + 1;
                for (int i = 0; i < months; i++)
                    dateTimes.Add(temp.AddMonths(i));
            }

            // Empty:
            var empty = from date in dateTimes
                        select new EmployeeCountByIntervalLine(date, 0);

            var output = new LinkedList<EmployeeCountByIntervalLine>();
            foreach (var e in empty)
            {
                DateTime beginDate = e.Date;
                DateTime endDate = timeInterval == TimeIntervalType.Month ? beginDate.AddMonths(1).AddDays(-1) : new DateTime(beginDate.Year, 12, 31);

                foreach (var employee in employeesQuery)
                {
                    if (employee.HiredOn <= endDate && (employee.FiredOn >= beginDate || employee.FiredOn == DateTime.MinValue))
                        e.Count++;
                }

                output.AddLast(e);
            }

            return output.OrderBy(x => x.Date);
        }

        private static void processHistoryStream(IICQHistoryStream history, string sUserNameFilter)
        {
            ICollection<IICQMessage> packets = new LinkedList<IICQMessage>();
            for (IICQMessage packet = history.parseNextPacket(); packet != null; packet = history.parseNextPacket())
            {
                if (string.IsNullOrEmpty(sUserNameFilter) || packet.OtherPartyName.Contains(sUserNameFilter))
                    packets.Add(packet);

                //if (packets.Count > 50)
                //    break;          // speed up for debugging
            }

            StringBuilder sbRTFOutput = new StringBuilder(100000);
            RichTextBox rtfAggregator = new RichTextBox();

            foreach (IICQMessage orderedPacket in packets.OrderBy<IICQMessage, DateTime>(packet => packet.TimeOfMessage))
            {
                rtfAggregator.Select(rtfAggregator.TextLength, 0);
                if (orderedPacket.isOutgoing)
                    rtfAggregator.SelectedRtf = SendRTF
                        .Replace("**NAME**", "*LocalUser*")
                        .Replace("**DATE**", orderedPacket.TimeOfMessage.ToLocalTime().ToString());
                else
                    rtfAggregator.SelectedRtf = ReceiveRTF
                        .Replace("**NAME**", orderedPacket.OtherPartyName)
                        .Replace("**DATE**", orderedPacket.TimeOfMessage.ToLocalTime().ToString());

                if (!string.IsNullOrEmpty(orderedPacket.TextRTF))
                {
                    rtfAggregator.Select(rtfAggregator.TextLength, 0);
                    rtfAggregator.SelectedRtf = orderedPacket.TextRTF;

                    //                  Console.WriteLine(orderedPacket.TextRTF);

                }
                else
                {
                    rtfAggregator.Select(rtfAggregator.TextLength, 0);
                    rtfAggregator.SelectedText = orderedPacket.Text + "\n";
                }

                //Console.WriteLine(orderedPacket.ToString());
            }

            Console.WriteLine(rtfAggregator.Rtf);
        }

        static void Main(string[] args)
        {
            CollectionType<Tor> collectionType_1 = new CollectionType<Tor>();
            Tor tor1 = new Tor("ator",10, 80);
            Tor tor2 = new Tor("btor",20, 90);
            Tor tor3 = new Tor("btor",30, 70);
            collectionType_1.Add(tor1);
            collectionType_1.Add(tor2);
            collectionType_1.Add(tor3);
            foreach (Tor value in collectionType_1)
                value.printInfo();
            WriteToFile(collectionType_1);

            collectionType_1.SortT();
            foreach (Tor value in collectionType_1)
                value.printInfo();

            CollectionType<Tor> collectionType_2 = new CollectionType<Tor>();
            Tor tor4 = new Tor("dtor",50, 80);
            Tor tor5 = new Tor("etor",20, 100);
            Tor tor6 = new Tor("ftor",30, 70);


            var linkedList = new LinkedList<CollectionType<Tor>>();
            linkedList.AddLast(collectionType_1);
            linkedList.AddFirst(collectionType_2);


            Console.WriteLine("where + OrderBy");
            var selectedTeams = collectionType_1.Where(t => t.Name.ToUpper().StartsWith("B")).OrderBy(t => t);
            foreach (Tor s in selectedTeams)
                s.printInfo();

            Console.WriteLine("Where( || + && + > )");
            var selectedTeams_2 = collectionType_1.Where(t => (t.innerRadius < 100 || t.outerRadius > 70) && t.innerRadius > 20);
            foreach (Tor s in selectedTeams_2)
                s.printInfo();

            Console.WriteLine("Where+Count");
            var selectedTeams_3 = (collectionType_1.Where(s => s.innerRadius < 90)).Count();
            Console.WriteLine(selectedTeams_3);

            Console.WriteLine("Select");
            var selectedTeams_4 = collectionType_1.Select((h, i) => new { Index = i + 1, h.Name });
            foreach (var el in selectedTeams_4)
                Console.WriteLine(el);


            Console.WriteLine("Min");
            var minRes = collectionType_1.Min(h => h.outerRadius);
            Console.WriteLine(minRes);

            Console.WriteLine("Max");
            var maxRes = collectionType_1.Max(h => h.outerRadius);
            Console.WriteLine(maxRes);

            Console.WriteLine("Join");
            var joinRes = collectionType_1.Join(collectionType_2, o => o.innerRadius, i => i.innerRadius, (o, i) => new Tor
            {
                Name = string.Format("{0}&{1}",o.Name,i.Name),
                innerRadius = o.innerRadius + i.innerRadius,
                outerRadius = o.outerRadius + i.outerRadius
            });
            foreach (var tor in joinRes)
                Console.WriteLine(tor);


            LinkedList<string> stringList = new LinkedList<string>();
            stringList.AddFirst("ЯАнтон");
            stringList.AddFirst("Саня");
            stringList.AddLast("Александр");
            WriteToFile(stringList);
            foreach (var value in stringList) Console.WriteLine("Значение: "+value);
            includeWord(stringList, "Саня");
            Console.WriteLine(lenghtString(stringList, 4));


            //var asc = stringList.OrderBy(v => v).ToList();
            var asc = stringList.OrderBy(v=>v);
            foreach (var value in asc) Console.WriteLine("Значение: " + value);
            Console.WriteLine("\n");
            var desc = stringList.OrderByDescending(v=>v);
            foreach (var value in desc) Console.WriteLine("Значение: " + value);

            Console.ReadKey();

        }

 private void Sjfp()
 {
     SortedProcesses = new LinkedList<Process>();
     var orderedEnumerable = Processes.OrderBy(x => x.ArrivalTime).ThenBy(x => x.BurstTime).ThenBy(x => x.Name);
     var tmpProcesses = new LinkedList<Process>(orderedEnumerable);
     var currentTime = tmpProcesses.First.Value.ArrivalTime;
     var lastTime = tmpProcesses.Last.Value.ArrivalTime;
     var nextTime = GetNextTime(tmpProcesses.First,currentTime);
     while (tmpProcesses.First != null)
     {
         if (currentTime < tmpProcesses.First.Value.ArrivalTime)
         {
             currentTime = tmpProcesses.First.Value.ArrivalTime;
             nextTime = GetNextTime(tmpProcesses.First, currentTime);
         }
         else if (currentTime >= lastTime)
         {
             var orderedEnumerable2 = tmpProcesses.OrderBy(x => x.BurstTime).ThenBy(x => x.ArrivalTime).ThenBy(x => x.Name);
             tmpProcesses = new LinkedList<Process>(orderedEnumerable2);
             while (tmpProcesses.First != null)
             {
                 var tmp = tmpProcesses.First.Value;
                 tmpProcesses.Remove(tmp);
                 if (SortedProcesses.Last != null && SortedProcesses.Last.Value.Name == tmp.Name)
                 {
                     SortedProcesses.Last.Value.BurstTime += tmp.BurstTime;
                 }
                 else
                 {
                     SortedProcesses.AddLast(tmp);
                 }
                 currentTime += tmp.BurstTime;
             }
         }
         else if (tmpProcesses.First.Value.BurstTime <= nextTime - currentTime)
         {
             var tmp = tmpProcesses.First.Value;
             tmpProcesses.Remove(tmp);
             if (SortedProcesses.Last != null && SortedProcesses.Last.Value.Name == tmp.Name)
             {
                 SortedProcesses.Last.Value.BurstTime += tmp.BurstTime;
             }
             else
             {
                 SortedProcesses.AddLast(tmp);
             }
             currentTime += tmp.BurstTime;
         }
         else if (tmpProcesses.First.Value.BurstTime > nextTime - currentTime)
         {
             PushPartOfProcess(tmpProcesses.First.Value, currentTime, nextTime - currentTime);
             currentTime = nextTime;
             SortAccordingToTime(tmpProcesses, currentTime);
             nextTime = GetNextTime(tmpProcesses.First, currentTime);
         }
     }
 }