C# 按工资降序排序，其中教师年=3

我有一份教师名单，我想按有3年工作经验的教师工资降序排列。

---

我想要经验3保留其索引（保留其位置）并仅按工资排序教师经验=3
请帮我解决这个问题

class Teacher
{
    public int id { get; set; }
    public string name { get; set; }
    public int year { get; set; }
    public double salary { get; set; }

    public Teacher()
    {
    }

    public Teacher(int id, string name, int year, double salary)
    {
        this.id = id;
        this.name = name;
        this.year = year;
        this.salary = salary;
    }
}

---

如果你真的想为有3年经验的教师筛选你的列表，那么你可以简单地使用linq应用Where扩展方法

var requiredTeachers=teacher.Where(x=>x.year==3).OrderByDescending(x=>x.salary).ToList();

---

如果你真的想为有3年经验的教师筛选你的列表，那么你可以简单地使用linq应用Where扩展方法

var requiredTeachers=teacher.Where(x=>x.year==3).OrderByDescending(x=>x.salary).ToList();

---

我只是猜测答案，因为一般来说，您的问题在需求中也不清楚，因为我假设输出是您已经得到的

根据我的回答，起初我想到的是

var t2 = teachers.Where(t => t.year == 3).OrderByDescending(t => t.salary);
var t3 = teachers.Where(t => !t2.Select(ts => ts.id).Contains(t.id));
var final = t2.Concat(t3);

是的，它不是最优的，可能有更好的方法来实现，但它会根据需要提供输出（？）

---

我只是猜测答案，因为一般来说，您的问题在需求中也不清楚，因为我假设输出是您已经得到的

根据我的回答，起初我想到的是

var t2 = teachers.Where(t => t.year == 3).OrderByDescending(t => t.salary);
var t3 = teachers.Where(t => !t2.Select(ts => ts.id).Contains(t.id));
var final = t2.Concat(t3);

是的，它不是最优的，可能有更好的方法来实现，但它会根据需要提供输出（？）

---

丑陋的解决方案，但有效：

注意：不需要转换为数组

using System;
using System.Linq;
using System.Collections.Generic;
                    
public class Program
{
    public static void Main()
    {
        List<Teacher> teacher = new List<Teacher>();
teacher.Add(new Teacher(1, "Teacher A", 4, 2000));
teacher.Add(new Teacher(2, "Teacher B", 3, 3000));
teacher.Add(new Teacher(3, "Teacher C", 5, 5000));
teacher.Add(new Teacher(4, "Teacher D", 3, 4000));
teacher.Add(new Teacher(5, "Teacher E", 3, 7000));
        
        var teachArr = teacher.ToArray();

        // Create separate List of only those teacher, you want to re-order
        // So, filter and sort.
        var threeYearTeachArr = teacher
                                  .Where(t => t.year == 3)           // Filter
                                  .OrderByDescending(t => t.salary)  // Sort
                                  .ToArray();                        // Do it!
        
        // Then replace all filtered items in the original collection
        // with the sorted ones. => Only filtered will change places.
        // We traverse 2 arrays, so we create two indexes and check both against their
        // respective collection sizes, but we increment only the "original"
        for( int i = 0, threes = 0; i < teachArr.Length && threes < threeYearTeachArr.Length; i++ )
        {
            // only if the current entry is one of those we sorted...
            if( teachArr[i].year == 3 ) 
            {
                // ... replace it with the next entry in the sorted list.
                // post-increment: use threes' value, then increment
                teachArr[i] = threeYearTeachArr[threes++]; 
            }
        }
                
        foreach( var t in teachArr )
        {
            Console.WriteLine($"{t.id} {t.name} | {t.year} | {t.salary}");
        }
    }
}

class Teacher
{
        public int id { get; set; }
        public string name { get; set; }
        public int year { get; set; }
        public double salary { get; set; }

        public Teacher()
        {
        }

        public Teacher(int id, string name, int year, double salary)
        {
            this.id = id;
            this.name = name;
            this.year = year;
            this.salary = salary;
        }
}

使用系统；
使用System.Linq；
使用System.Collections.Generic；
公共课程
{
公共静态void Main（）
{
列表教师=新列表（）；
增加（新教师（1名，“教师A”，2000年4月）；
增加（新教师（2名，“教师B”，33000人）；
增加（新教师（3名，“C教师”，55000人）；
增加（新教师（4名，“D教师”，34000人）；
增加（新教师（5名，“E教师”，37000人）；
var teachar=teacher.ToArray（）；
//仅创建要重新排序的教师的单独列表
//所以，过滤和排序。
var Threeyearteachar=教师
.Where（t=>t.year==3）//过滤器
.OrderByDescending（t=>t.salary）//排序
.ToArray（）；//做吧！
//然后替换原始集合中的所有筛选项
//对于已排序的位置。=>只有已筛选的才会更改位置。
//我们遍历2个数组，因此我们创建了两个索引，并根据它们的
//各自的集合大小，但我们只增加“原始”
for（int i=0，threes=0；i

输出：

1 Teacher A | 4 | 2000 5 Teacher E | 3 | 7000 3 Teacher C | 5 | 5000 4 Teacher D | 3 | 4000 2 Teacher B | 3 | 3000 1名教师A | 4 | 2000 5名教师E | 3 | 7000 3名教师C| 5 | 5000 4名教师D | 3 | 4000 2名教师B | 3 | 3000

---

请参见行动：丑陋的解决方案，但正在工作：

注意：不需要转换为数组

using System;
using System.Linq;
using System.Collections.Generic;
                    
public class Program
{
    public static void Main()
    {
        List<Teacher> teacher = new List<Teacher>();
teacher.Add(new Teacher(1, "Teacher A", 4, 2000));
teacher.Add(new Teacher(2, "Teacher B", 3, 3000));
teacher.Add(new Teacher(3, "Teacher C", 5, 5000));
teacher.Add(new Teacher(4, "Teacher D", 3, 4000));
teacher.Add(new Teacher(5, "Teacher E", 3, 7000));
        
        var teachArr = teacher.ToArray();

        // Create separate List of only those teacher, you want to re-order
        // So, filter and sort.
        var threeYearTeachArr = teacher
                                  .Where(t => t.year == 3)           // Filter
                                  .OrderByDescending(t => t.salary)  // Sort
                                  .ToArray();                        // Do it!
        
        // Then replace all filtered items in the original collection
        // with the sorted ones. => Only filtered will change places.
        // We traverse 2 arrays, so we create two indexes and check both against their
        // respective collection sizes, but we increment only the "original"
        for( int i = 0, threes = 0; i < teachArr.Length && threes < threeYearTeachArr.Length; i++ )
        {
            // only if the current entry is one of those we sorted...
            if( teachArr[i].year == 3 ) 
            {
                // ... replace it with the next entry in the sorted list.
                // post-increment: use threes' value, then increment
                teachArr[i] = threeYearTeachArr[threes++]; 
            }
        }
                
        foreach( var t in teachArr )
        {
            Console.WriteLine($"{t.id} {t.name} | {t.year} | {t.salary}");
        }
    }
}

class Teacher
{
        public int id { get; set; }
        public string name { get; set; }
        public int year { get; set; }
        public double salary { get; set; }

        public Teacher()
        {
        }

        public Teacher(int id, string name, int year, double salary)
        {
            this.id = id;
            this.name = name;
            this.year = year;
            this.salary = salary;
        }
}

使用系统；
使用System.Linq；
使用System.Collections.Generic；
公共课程
{
公共静态void Main（）
{
列表教师=新列表（）；
增加（新教师（1名，“教师A”，2000年4月）；
增加（新教师（2名，“教师B”，33000人）；
增加（新教师（3名，“C教师”，55000人）；
增加（新教师（4名，“D教师”，34000人）；
增加（新教师（5名，“E教师”，37000人）；
var teachar=teacher.ToArray（）；
//仅创建要重新排序的教师的单独列表
//所以，过滤和排序。
var Threeyearteachar=教师
.Where（t=>t.year==3）//过滤器
.OrderByDescending（t=>t.salary）//排序
.ToArray（）；//做吧！
//然后替换原始集合中的所有筛选项
//对于已排序的位置。=>只有已筛选的才会更改位置。
//我们遍历2个数组，因此我们创建了两个索引，并根据它们的
//各自的集合大小，但我们只增加“原始”
for（int i=0，threes=0；ifor (int i1 = 0; i1 < teacher.Count; i1++)
{
    if (teacher[i1].year != 3)
        continue;

    for (int i2 = i1 + 1; i2 < teacher.Count; i2++)
    {
        if (teacher[i2].year != 3)
            continue;
            
        if (teacher[i1].salary > teacher[i2].salary)
            (teacher[i1], teacher[i2]) = (teacher[i2], teacher[i1]);
    }
}

List<Teacher> SortYear3(IEnumerable<Teacher> source)
{
    var indexed = source.Select((teacher, index) => (index, teacher)).ToArray();
    var pass = indexed.Where(pair => pair.teacher.year == 3);
    var passIndices = pass.Select(pair => pair.index).ToArray();
    var passOrdered = pass.Select(pair => pair.teacher).OrderByDescending(teacher => teacher.salary).ToArray();
    var reindex = Enumerable.Range(0, passIndices.Length).Select(i => (index: passIndices[i], teacher: passOrdered[i]));
    var merged = indexed.Where(pair => pair.teacher.year != 3).Concat(reindex).OrderBy(p => p.index);
    
    return merged.Select(pair => pair.teacher).ToList();
}

List<Teacher> SortYear3(List<Teacher> source)
{
    var sorted = source.Where(t => t.year == 3).OrderByDescending(t => t.salary).ToArray();
    var result = new List<Teacher>();
    for (int i = 0, sortindex = 0; i < source.Count; i++)
    {
        var next = source[i];
        if (next.year == 3)
            result.Add(sorted[sortindex++]);
        else
            result.Add(next);
    }
    return result;
}

List<Teacher> SortYear3(List<Teacher> source)
{
    var sorted = source.Where(t => t.year == 3).OrderByDescending(t => t.salary).ToArray();
    var result = source.ToList();
    for (int i = 0, sortindex = 0; i < result.Count; i++)
    {
        if (result[i].year == 3)
            result[i] = sorted[sortindex++];
    }
    return result;
}

IEnumerable<T> SortSelected<T, TKey>(IEnumerable<T> source, Func<T, bool> filter, Func<T, TKey> sortKey, bool descending = true)
{
    var result = source.ToList();
    var filtered = result.Where(filter);
    var sorted = (descending ? filtered.OrderByDescending(sortKey) : filtered.OrderBy(sortKey)).ToArray();
    for (int i = 0, j = 0; j < sorted.Count; i++)
    {
        if (filter(result[i]))
            result[i] = sorted[j++];
    }
    return result;
}

List<Teacher> SortYear3(List<Teacher> source)
    => SortSelected(source, t => t.year == 3, t => t.salary, true).ToList();

using System;
using System.Xml.Serialization;
using System.Collections.Generic;
using System.Linq;
                
public class Program
{
public static void Main()
{
List<Teacher> teacher = new List<Teacher>();
teacher.Add(new Teacher(1, "Teacher A", 4, 2000));
teacher.Add(new Teacher(2, "Teacher B", 3, 3000));
teacher.Add(new Teacher(3, "Teacher C", 5, 5000));
teacher.Add(new Teacher(4, "Teacher D", 3, 4000));
teacher.Add(new Teacher(5, "Teacher E", 3, 7000));
    
var expTeacher=teacher.Where(x=>x.year==3).OrderByDescending(x=>x.salary).ToList();

    for(int i=0,j=0;i<teacher.Count && j<expTeacher.Count;i++)
    {
        if(teacher[i].year==3)
        {
            teacher[i]= expTeacher[j];
            j++;
        }
    }
    foreach(var teach in teacher)
    {
        
    Console.WriteLine(teach.id+", "+teach.name+", "+teach.year+", "+teach.salary);
    }
    
    
    
   }
   }
   class Teacher
   {
    public int id { get; set; }
    public string name { get; set; }
    public int year { get; set; }
    public double salary { get; set; }

    public Teacher()
    {
    }

    public Teacher(int id, string name, int year, double salary)
    {
        this.id = id;
        this.name = name;
        this.year = year;
        this.salary = salary;
    }
    }

 List<Coach> sorted = coaches.Where(x => x.YearOfExperience == 3).OrderByDescending(x => x.Salary).ToList();
            List<Coach> originalList = coaches;
            int index = 0;
            for (int i = 0; i < originalList.Count; i++)
            {
                if (originalList[i].YearOfExperience == 3)
                {
                    originalList[i] = sorted[index++];
                }
            }
            foreach (var item in originalList)
            {
                item.show();
            }